Merged revisions 2725-2865 via svnmerge from

http://scons.tigris.org/svn/scons/branches/core

........
  r2731 | stevenknight | 2008-04-01 09:22:37 -0700 (Tue, 01 Apr 2008) | 4 lines

  Fix test/Interactive/version.py, which still had the old hard-coded
  Copyright string, by moving the test copy of the Copyright string
  into QMTest/TestSCons.py, where it's available to all test scripts.
........
  r2732 | stevenknight | 2008-04-02 13:28:32 -0700 (Wed, 02 Apr 2008) | 3 lines

  Issues 317, 323, 329:  Ignore the -d, -e and -w options, which we're
  not going to implement.
........
  r2734 | stevenknight | 2008-04-05 07:50:49 -0700 (Sat, 05 Apr 2008) | 2 lines

  Fix bootstrap.py for pre-2.3 versions of Python, which don't have __file__.
........
  r2735 | stevenknight | 2008-04-05 07:54:44 -0700 (Sat, 05 Apr 2008) | 2 lines

  Fix the non-breaking-hyphen regular expression(s) for Python 1.5.
........
  r2736 | garyo | 2008-04-05 19:15:52 -0700 (Sat, 05 Apr 2008) | 1 line

  Added Users Guide section for AddMethod.
........
  r2737 | stevenknight | 2008-04-08 09:43:31 -0700 (Tue, 08 Apr 2008) | 3 lines

  Don't raise strings as exceptions in the exception-handling unit tests.
  That's now deprecated Python behavior.
........
  r2738 | stevenknight | 2008-04-08 10:36:00 -0700 (Tue, 08 Apr 2008) | 5 lines

  Address a serious inefficiency in Java builds by moving the pre-build
  check for whether source files exist from the Node class to the Executor
  class, so we only have to perform the check once when building a whole
  bunch of targets from a whole bunch of sources.
........
  r2739 | stevenknight | 2008-04-08 13:53:44 -0700 (Tue, 08 Apr 2008) | 2 lines

  Add a backwards-compatibility version of the "itertools" module.
........
  r2740 | stevenknight | 2008-04-08 14:12:05 -0700 (Tue, 08 Apr 2008) | 2 lines

  Issue 1961:  speed up SCons.Util.to_String*() functions.  (Benoit Belley)
........
  r2741 | stevenknight | 2008-04-08 14:15:36 -0700 (Tue, 08 Apr 2008) | 2 lines

  Use the itertools.izip() method for some key Node.FS methods.  (Benoit Belley)
........
  r2742 | stevenknight | 2008-04-08 14:35:35 -0700 (Tue, 08 Apr 2008) | 2 lines

  Issues 1961:  use izip() instead of zip() where possible (Benoit Belley)
........
  r2743 | stevenknight | 2008-04-08 14:48:08 -0700 (Tue, 08 Apr 2008) | 3 lines

  Issue 1961:  more efficient get_contents() implementation for Python
  function Actions.  (Benoit Belley)
........
  r2744 | stevenknight | 2008-04-08 17:55:30 -0700 (Tue, 08 Apr 2008) | 3 lines

  Issue 1961:  make SCons.Node.* state variables global in Taskmaster.py so
  we avoid unneceesary attribute fetches.  (Benoit Belley)
........
  r2745 | stevenknight | 2008-04-08 20:40:31 -0700 (Tue, 08 Apr 2008) | 2 lines

  Issue 1961:  Optimize the code in Node.get_binfo().  (Benoit Belley)
........
  r2746 | stevenknight | 2008-04-08 21:05:17 -0700 (Tue, 08 Apr 2008) | 3 lines

  Issue 1961:  Enhance the backwards-compatibility sets() module with the
  ability to compare sets.  (Benoit Belley)
........
  r2747 | stevenknight | 2008-04-08 22:11:20 -0700 (Tue, 08 Apr 2008) | 2 lines

  Issue 1961:  Optimize Executor.scan().  (Benoit Belley)
........
  r2748 | stevenknight | 2008-04-08 22:17:55 -0700 (Tue, 08 Apr 2008) | 3 lines

  Python 1.5 compatibility:  use for p in paths.keys() for dictionaries.
  (Benoit Belley)
........
  r2749 | stevenknight | 2008-04-08 22:54:02 -0700 (Tue, 08 Apr 2008) | 10 lines

  Issue 1961:  additional build optimizations:
  --  Make taskmastertrace output more useful and readable.
  --  Move dependency cycle checking to avoid re-doing it.
  --  Have Nodes use sets, not dictionaries, to track various things.
  --  Eliminate intermediate function calls from fetching Node children.
  --  Add a Task.needs_execute() method to avoid doing that check over and
      over as part of needs_execute().
  --  Remove the unused Node.found_includes attribute.
  (Benoit Belley)
........
  r2750 | stevenknight | 2008-04-09 14:47:44 -0700 (Wed, 09 Apr 2008) | 4 lines

  Make target Java .class files depend *only* on the input .java files as
  their sources when determining if they require rebuilding.  This eliminates
  O(NxM) checking for every single edge in a big, overly-connected DAG mesh.
........
  r2751 | stevenknight | 2008-04-09 16:58:41 -0700 (Wed, 09 Apr 2008) | 2 lines

  Remove 0.95 and 0.96* release notes.
........
  r2752 | stevenknight | 2008-04-10 02:24:50 -0700 (Thu, 10 Apr 2008) | 2 lines

  Issue 1956:  Fix --debug=stree printing its tree twice.  (Benoit Belley)
........
  r2753 | stevenknight | 2008-04-10 02:33:28 -0700 (Thu, 10 Apr 2008) | 2 lines

  Issue 1896:  Add support for the GDC D language compiler.  (Matthew Wesley)
........
  r2754 | stevenknight | 2008-04-10 02:39:24 -0700 (Thu, 10 Apr 2008) | 2 lines

  Fix tabs.
........
  r2755 | stevenknight | 2008-04-10 02:41:50 -0700 (Thu, 10 Apr 2008) | 3 lines

  Issue 1964:  Fix passing variable names in a list to Return() (as
  already documented in the man page!)  (Mike Wake)
........
  r2756 | stevenknight | 2008-04-10 02:55:40 -0700 (Thu, 10 Apr 2008) | 2 lines

  Support the ability to download 2.6 candidate releases (e.g. 2.6a2).
........
  r2757 | stevenknight | 2008-04-10 02:58:35 -0700 (Thu, 10 Apr 2008) | 3 lines

  Issue 1669:  Fix the ability to use LoadableModule() under MinGW.
  (Johan Boule)
........
  r2758 | stevenknight | 2008-04-10 03:03:15 -0700 (Thu, 10 Apr 2008) | 3 lines

  Update the test/Interactive/tree.py script for Benoit's fix to
  remove duplicate tree printing.
........
  r2759 | stevenknight | 2008-04-10 06:43:44 -0700 (Thu, 10 Apr 2008) | 3 lines

  Fix Tool/dmd.py when no D compiler is installed -- we don't want to
  search for a path if the result is None.
........
  r2760 | GregNoel | 2008-04-10 15:30:34 -0700 (Thu, 10 Apr 2008) | 1 line

  Issue 2009: separate Debug.caller() by functionality
........
  r2761 | stevenknight | 2008-04-11 04:47:25 -0700 (Fri, 11 Apr 2008) | 3 lines

  Issue 1882:  Add the scons.bat directory to %PATH% so it can find python.exe.
  (Anatoly Techtonik)
........
  r2762 | stevenknight | 2008-04-11 09:15:22 -0700 (Fri, 11 Apr 2008) | 4 lines

  Issues 1835,1901:  fix the ability to list a source file multiple
  times for a target by making sure we only store unique entries in the
  .sconsign file.
........
  r2763 | stevenknight | 2008-04-11 10:58:26 -0700 (Fri, 11 Apr 2008) | 4 lines

  Issue 1882:  Fix earlier patch to scons.bat by adding ~dp0;~dp0.. to
  the front of %PATH%, and only executing endlocal on NT-based systems.
  (Anatoly Techtonik)
........
  r2764 | stevenknight | 2008-04-11 13:06:29 -0700 (Fri, 11 Apr 2008) | 4 lines

  Add a Variables object and {Bool,Envum,List,Package,Path}Variable()
  functions as a first step towards eventually deprecating the
  Options object and {Bool,Envum,List,Package,Path}Option() functions.
........
  r2765 | stevenknight | 2008-04-11 18:13:53 -0700 (Fri, 11 Apr 2008) | 3 lines

  Issue 1962:  Capture a test case for ListActions that contain a
  command-line string containing unicode, and Python FunctionAction.
........
  r2766 | stevenknight | 2008-04-11 22:03:14 -0700 (Fri, 11 Apr 2008) | 3 lines

  Issue 1933:  expect .py files generated by the SWIG -python option
  to be in the same (sub)directory as the target.
........
  r2767 | stevenknight | 2008-04-12 06:41:57 -0700 (Sat, 12 Apr 2008) | 2 lines

  Remove the SCons.Options package in favor of the new SCons.Variables package.
........
  r2768 | stevenknight | 2008-04-12 13:33:52 -0700 (Sat, 12 Apr 2008) | 5 lines

  Issue 1971:  Move the incorporation of $CCFLAGS and $SHCCFLAGS directly
  into the C++ command lines (${SHCXX,CXX}COM) instead of through indirect
  expansion of $CXXFLAGS and $SHCXXFLAGS.  This requires removing -fPIC
  from the default setting of $SHCXXFLAGS under the GNU toolchain.
........
  r2769 | stevenknight | 2008-04-13 07:01:27 -0700 (Sun, 13 Apr 2008) | 3 lines

  Fix __all__ definitions in the Variables/*Variable.py file that were
  cause epydoc to blow up when generating developer documentation.
........
  r2770 | stevenknight | 2008-04-13 11:47:49 -0700 (Sun, 13 Apr 2008) | 3 lines

  Add variables= keyword argument to Environment() creation as a first
  step towards deprecating options=.
........
  r2771 | stevenknight | 2008-04-13 11:54:19 -0700 (Sun, 13 Apr 2008) | 2 lines

  Correct underscore-instead-of-hyphen misspellings in option names.
........
  r2772 | bdbaddog | 2008-04-13 17:39:21 -0700 (Sun, 13 Apr 2008) | 3 lines

  Changes to fix 15 tests which were failing on cygwin.
........
  r2773 | GregNoel | 2008-04-13 22:31:07 -0700 (Sun, 13 Apr 2008) | 1 line

  Various fixes to tests on Darwin using 1.5.2
........
  r2774 | stevenknight | 2008-04-14 15:00:44 -0700 (Mon, 14 Apr 2008) | 2 lines

  Python 1.5.2 fix in new test/SWIG/subdir.py script (use the -classic option).
........
  r2775 | belley | 2008-04-14 18:02:40 -0700 (Mon, 14 Apr 2008) | 32 lines

  Dont use KeyboardInterrupt to stop a build! [Issue 1907]

  SCons would often hang after pressing Ctrl-C. I started investigating and I
  realized that most of the Python libraries are not really safe with respect to
  asynchronous exceptions. Although,there are enough try/finally blocks to handle
  exceptions thrown synchronously by the library code, the Python libraries are
  not always protected against exceptions being thrown asynchronously, such as a
  KeyboardInterrupt being thrown at a completely random location.

  For example, the function Queue.empty() does not protect its mutex with a
  try/finally block. If the KeyboardInterrupt exception gets thrown while the
  mutex is held, any further attempt to access the Queue will lead to dead-lock
  (explaining why SCons hangs sometimes after pressing CTRL-C). Even the
  threading.Condition condition variables are not async-exception safe. It
  therefore seems a lost battle to try to stop a build by raising an exception.

  Instead, I have implemented a signal handler that tells the Jobs (and its
  associated Taskmaster) to stop the build. I have been careful to wait after the
  .sconsign file has been written back to re-install the default SIGINT signal
  handler that raises a KeyboardInterrupt exception.

  This patch is submitted against changeset 2773 of branches/core. The
  regression test suite has been run on RHEL4 using Pyhon 2.5.1 and
  1.5.2. My team has been using an SCons build with this patch for a
  while now on Windows, Linux and OSX.

  See:
  http://scons.tigris.org/issues/show_bug.cgi?id=1907

  Benoit Belley
........
  r2777 | cournape | 2008-04-14 20:11:56 -0700 (Mon, 14 Apr 2008) | 3 lines

  Initialized merge tracking via "svnmerge" with revisions "1-2776" from
  http://scons.tigris.org/svn/scons/branches/fortran_refactor
........
  r2788 | stevenknight | 2008-04-14 22:09:27 -0700 (Mon, 14 Apr 2008) | 2 lines

  Fix the print the "script" line in the --version output.
........
  r2789 | stevenknight | 2008-04-14 22:18:27 -0700 (Mon, 14 Apr 2008) | 2 lines

  Add a __COPYRIGHT__ line.
........
  r2790 | stevenknight | 2008-04-14 22:20:39 -0700 (Mon, 14 Apr 2008) | 3 lines

  Issue 2008:  in checkpoint releases, use a '.' to separate (e.g.) 0.98.0
  from 0d20080414.
........
  r2817 | belley | 2008-04-15 06:44:21 -0700 (Tue, 15 Apr 2008) | 13 lines

  TestSCons.up_to_date() should use match_re_dotall

  I changed TestSCons.up_to_date() to use match_re_dotall instead of
  match_exact. This is necessary so that I can call up_to_date() with
  the TestSCons.deprecated_python_expr error message in one of my test.

  Note that TestSCons.not_up_to_date() is already using match_re_dotall.

  Ran the test suite on both Python 2.5.1 and 1.5.2.

  Benoit
........
  r2818 | belley | 2008-04-15 12:10:52 -0700 (Tue, 15 Apr 2008) | 10 lines

  Improved the multiple-parents.py test to also tests the following
  cases:

  d) Some children are ignored
  e) Some children are pre-requesites
  f) Some sources are missing

  The test still passes. No extra bug were found.
........
  r2850 | stevenknight | 2008-04-16 11:15:24 -0700 (Wed, 16 Apr 2008) | 4 lines

  Fix problems with the __del__() method referencing other module functions
  through global variables, which can get deleted out from under us at
  shutdown.
........
  r2851 | stevenknight | 2008-04-16 11:17:07 -0700 (Wed, 16 Apr 2008) | 4 lines

  Fix use of --interactive with -u/-U/-D and VariantDir() by making the
  method that cleans Node states between interactive commands aware of
  the alter_targets() method that tells us about an associated VariantDir().
........

1 files changed, 0 insertions, 552 deletions

diff --git a/src/engine/SCons/Options/OptionsTests.py b/src/engine/SCons/Options/OptionsTests.py
deleted file mode 100644
index 5ec9d7a..0000000
--- a/src/engine/SCons/Options/OptionsTests.py
+++ /dev/null
@@ -1,552 +0,0 @@
-#
-# __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 string
-import sys
-import unittest
-import TestSCons
-
-import SCons.Options
-import SCons.Subst
-import SCons.Warnings
-
-
-class Environment:
-    def __init__(self):
-        self.dict = {}
-    def subst(self, x):
-        return SCons.Subst.scons_subst(x, self, gvars=self.dict)
-    def __setitem__(self, key, value):
-        self.dict[key] = value
-    def __getitem__(self, key):
-        return self.dict[key]
-    def has_key(self, key):
-        return self.dict.has_key(key)
-
-
-def check(key, value, env):
-    assert int(value) == 6 * 9, "key %s = %s" % (key, repr(value))
-    
-# Check saved option file by executing and comparing against
-# the expected dictionary
-def checkSave(file, expected):
-    gdict = {}
-    ldict = {}
-    execfile(file, gdict, ldict)
-    assert expected == ldict, "%s\n...not equal to...\n%s" % (expected, ldict)
-
-class OptionsTestCase(unittest.TestCase):
-
-    def test_keys(self):
-        """Test the Options.keys() method"""
-        opts = SCons.Options.Options()
-
-        opts.Add('VAR1')
-        opts.Add('VAR2',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-        keys = opts.keys()
-        assert keys == ['VAR1', 'VAR2'], keys
-
-    def test_Add(self):
-        """Test adding to an Options object"""
-        opts = SCons.Options.Options()
-
-        opts.Add('VAR')
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        o = opts.options[0]
-        assert o.key == 'VAR'
-        assert o.help == ''
-        assert o.default == None
-        assert o.validator == None
-        assert o.converter == None
-
-        o = opts.options[1]
-        assert o.key == 'ANSWER'
-        assert o.help == 'THE answer to THE question'
-        assert o.default == "42"
-        o.validator(o.key, o.converter(o.default), {})
-
-        def test_it(var, opts=opts):
-            exc_caught = None
-            try:
-                opts.Add(var)
-            except SCons.Errors.UserError:
-                exc_caught = 1
-            assert exc_caught, "did not catch UserError for '%s'" % var
-        test_it('foo/bar')
-        test_it('foo-bar')
-        test_it('foo.bar')
-
-    def test_AddOptions(self):
-        """Test adding a list of options to an Options object"""
-        opts = SCons.Options.Options()
-
-        opts.AddOptions(('VAR2',),
-                        ('ANSWER2',
-                         'THE answer to THE question',
-                         "42",
-                         check,
-                         lambda x: int(x) + 12))
-
-        o = opts.options[0]
-        assert o.key == 'VAR2', o.key
-        assert o.help == '', o.help
-        assert o.default == None, o.default
-        assert o.validator == None, o.validator
-        assert o.converter == None, o.converter
-
-        o = opts.options[1]
-        assert o.key == 'ANSWER2', o.key
-        assert o.help == 'THE answer to THE question', o.help
-        assert o.default == "42", o.default
-        o.validator(o.key, o.converter(o.default), {})
-
-    def test_Update(self):
-        """Test updating an Environment"""
-
-        # Test that a default value is validated correctly.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env)
-        assert env['ANSWER'] == 54
-
-        env = Environment()
-        opts.Update(env, {})
-        assert env['ANSWER'] == 54
-
-        # Test that a bad value from the file is used and
-        # validation fails correctly.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=54')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        exc_caught = None
-        try:
-            opts.Update(env)
-        except AssertionError:
-            exc_caught = 1
-        assert exc_caught, "did not catch expected assertion"
-
-        env = Environment()
-        exc_caught = None
-        try:
-            opts.Update(env, {})
-        except AssertionError:
-            exc_caught = 1
-        assert exc_caught, "did not catch expected assertion"
-
-        # Test that a good value from the file is used and validated.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=42')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "10",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env)
-        assert env['ANSWER'] == 54
-
-        env = Environment()
-        opts.Update(env, {})
-        assert env['ANSWER'] == 54
-
-        # Test that a bad value from an args dictionary passed to
-        # Update() is used and validation fails correctly.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=10')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "12",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        exc_caught = None
-        try:
-            opts.Update(env, {'ANSWER':'54'})
-        except AssertionError:
-            exc_caught = 1
-        assert exc_caught, "did not catch expected assertion"
-
-        # Test that a good value from an args dictionary
-        # passed to Update() is used and validated.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=10')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "12",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env, {'ANSWER':'42'})
-        assert env['ANSWER'] == 54
-
-        # Test against a former bug.  If we supply a converter,
-        # but no default, the value should *not* appear in the
-        # Environment if no value is specified in the options file
-        # or args.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        opts = SCons.Options.Options(file)
-        
-        opts.Add('ANSWER',
-                 help='THE answer to THE question',
-                 converter=str)
-
-        env = Environment()
-        opts.Update(env, {})
-        assert not env.has_key('ANSWER')
-
-        # Test that a default value of None is all right.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        opts = SCons.Options.Options(file)
-
-        opts.Add('ANSWER',
-                 "This is the answer",
-                 None,
-                 check)
-
-        env = Environment()
-        opts.Update(env, {})
-        assert not env.has_key('ANSWER')
-
-    def test_args(self):
-        """Test updating an Environment with arguments overridden"""
-
-        # Test that a bad (command-line) argument is used
-        # and the validation fails correctly.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=42')
-        opts = SCons.Options.Options(file, {'ANSWER':54})
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        exc_caught = None
-        try:
-            opts.Update(env)
-        except AssertionError:
-            exc_caught = 1
-        assert exc_caught, "did not catch expected assertion"
-
-        # Test that a good (command-line) argument is used and validated.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=54')
-        opts = SCons.Options.Options(file, {'ANSWER':42})
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "54",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env)
-        assert env['ANSWER'] == 54
-
-        # Test that a (command-line) argument is overridden by a dictionary
-        # supplied to Update() and the dictionary value is validated correctly.
-        test = TestSCons.TestSCons()
-        file = test.workpath('custom.py')
-        test.write('custom.py', 'ANSWER=54')
-        opts = SCons.Options.Options(file, {'ANSWER':54})
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "54",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env, {'ANSWER':42})
-        assert env['ANSWER'] == 54
-
-    def test_Save(self):
-        """Testing saving Options"""
-
-        test = TestSCons.TestSCons()
-        cache_file = test.workpath('cached.options')
-        opts = SCons.Options.Options()
-
-        def bool_converter(val):
-            if val in [1, 'y']: val = 1
-            if val in [0, 'n']: val = 0
-            return val
-        
-        # test saving out empty file
-        opts.Add('OPT_VAL',
-                 'An option to test',
-                 21,
-                 None,
-                 None)
-        opts.Add('OPT_VAL_2',
-                 default='foo')
-        opts.Add('OPT_VAL_3',
-                 default=1)
-        opts.Add('OPT_BOOL_0',
-                 default='n',
-                 converter=bool_converter)
-        opts.Add('OPT_BOOL_1',
-                 default='y',
-                 converter=bool_converter)
-        opts.Add('OPT_BOOL_2',
-                 default=0,
-                 converter=bool_converter)
-
-        env = Environment()
-        opts.Update(env, {'OPT_VAL_3' : 2})
-        assert env['OPT_VAL'] == 21, env['OPT_VAL']
-        assert env['OPT_VAL_2'] == 'foo', env['OPT_VAL_2']
-        assert env['OPT_VAL_3'] == 2, env['OPT_VAL_3']
-        assert env['OPT_BOOL_0'] == 0, env['OPT_BOOL_0']
-        assert env['OPT_BOOL_1'] == 1, env['OPT_BOOL_1']
-        assert env['OPT_BOOL_2'] == '0', env['OPT_BOOL_2']
-
-        env['OPT_VAL_2'] = 'bar'
-        env['OPT_BOOL_0'] = 0
-        env['OPT_BOOL_1'] = 1
-        env['OPT_BOOL_2'] = 2
-
-        opts.Save(cache_file, env)
-        checkSave(cache_file, { 'OPT_VAL_2' : 'bar',
-                                'OPT_VAL_3' : 2,
-                                'OPT_BOOL_2' : 2})
-
-        # Test against some old bugs
-        class Foo:
-            def __init__(self, x):
-                self.x = x
-            def __str__(self):
-                return self.x
-            
-        test = TestSCons.TestSCons()
-        cache_file = test.workpath('cached.options')
-        opts = SCons.Options.Options()
-        
-        opts.Add('THIS_USED_TO_BREAK',
-                 'An option to test',
-                 "Default")
-
-        opts.Add('THIS_ALSO_BROKE',
-                 'An option to test',
-                 "Default2")
-        
-        opts.Add('THIS_SHOULD_WORK',
-                 'An option to test',
-                 Foo('bar'))
-        
-        env = Environment()
-        opts.Update(env, { 'THIS_USED_TO_BREAK' : "Single'Quotes'In'String",
-                           'THIS_ALSO_BROKE' : "\\Escape\nSequences\t",
-                           'THIS_SHOULD_WORK' : Foo('baz') })
-        opts.Save(cache_file, env)
-        checkSave(cache_file, { 'THIS_USED_TO_BREAK' : "Single'Quotes'In'String",
-                                'THIS_ALSO_BROKE' : "\\Escape\nSequences\t",
-                                'THIS_SHOULD_WORK' : 'baz' })
-
-    def test_GenerateHelpText(self):
-        """Test generating the default format help text"""
-        opts = SCons.Options.Options()
-
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        opts.Add('B',
-                 'b - alpha test',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        opts.Add('A',
-                 'a - alpha test',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env, {})
-
-        expect = """
-ANSWER: THE answer to THE question
-    default: 42
-    actual: 54
-
-B: b - alpha test
-    default: 42
-    actual: 54
-
-A: a - alpha test
-    default: 42
-    actual: 54
-"""
-
-        text = opts.GenerateHelpText(env)
-        assert text == expect, text
-
-        expectAlpha = """
-A: a - alpha test
-    default: 42
-    actual: 54
-
-ANSWER: THE answer to THE question
-    default: 42
-    actual: 54
-
-B: b - alpha test
-    default: 42
-    actual: 54
-"""
-        text = opts.GenerateHelpText(env, sort=cmp)
-        assert text == expectAlpha, text
-
-    def test_FormatOptionHelpText(self):
-        """Test generating custom format help text"""
-        opts = SCons.Options.Options()
-
-        def my_format(env, opt, help, default, actual, aliases):
-            return '%s %s %s %s %s\n' % (opt, default, actual, help, aliases)
-
-        opts.FormatOptionHelpText = my_format
-
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        opts.Add('B',
-                 'b - alpha test',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        opts.Add('A',
-                 'a - alpha test',
-                 "42",
-                 check,
-                 lambda x: int(x) + 12)
-
-        env = Environment()
-        opts.Update(env, {})
-
-        expect = """\
-ANSWER 42 54 THE answer to THE question ['ANSWER']
-B 42 54 b - alpha test ['B']
-A 42 54 a - alpha test ['A']
-"""
-
-        text = opts.GenerateHelpText(env)
-        assert text == expect, text
-
-        expectAlpha = """\
-A 42 54 a - alpha test ['A']
-ANSWER 42 54 THE answer to THE question ['ANSWER']
-B 42 54 b - alpha test ['B']
-"""
-        text = opts.GenerateHelpText(env, sort=cmp)
-        assert text == expectAlpha, text
-
-
-
-class UnknownOptionsTestCase(unittest.TestCase):
-
-    def test_unknown(self):
-        """Test the UnknownOptions() method"""
-        opts = SCons.Options.Options()
-        
-        opts.Add('ANSWER',
-                 'THE answer to THE question',
-                 "42")
-
-        args = {
-            'ANSWER'    : 'answer',
-            'UNKNOWN'   : 'unknown',
-        }
-
-        env = Environment()
-        opts.Update(env, args)
-
-        r = opts.UnknownOptions()
-        assert r == {'UNKNOWN' : 'unknown'}, r
-        assert env['ANSWER'] == 'answer', env['ANSWER']
-
-
-
-if __name__ == "__main__":
-    suite = unittest.TestSuite()
-    tclasses = [ OptionsTestCase,
-                 UnknownOptionsTestCase ]
-    for tclass in tclasses:
-        names = unittest.getTestCaseNames(tclass, 'test_')
-        suite.addTests(map(tclass, names))
-    if not unittest.TextTestRunner().run(suite).wasSuccessful():
-        sys.exit(1)