From 3a0d7f1915db1f192f63600dec0831a4020e94b807f5b08147df13dad663d0a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Chv=C3=A1tal?= Date: Sun, 7 Oct 2018 12:11:44 +0000 Subject: [PATCH] Accepting request 640345 from home:mcepl:work - Block failing tests (and block %check section completely on non-Intel archs, as the tests are apparently not designed for that). - FIx patches from the upstream to improve compatbiilty: fix-jN-for-python-37.patch fix-rpm-tests-for-newer-rpmbuild.patch no_deprecated_asserts.patch no_time-clock.patch removed_splitunc.patch replace_TestSuite_main.patch stop_custom_OrderedDict.patch OBS-URL: https://build.opensuse.org/request/show/640345 OBS-URL: https://build.opensuse.org/package/show/devel:tools:building/scons?expand=0&rev=62 --- 3.0.1.tar.gz | 3 + fix-jN-for-python-37.patch | 26 + fix-rpm-tests-for-newer-rpmbuild.patch | 114 ++++ grep-filter-list.txt | 312 +++++++++++ no_deprecated_asserts.patch | 400 ++++++++++++++ no_time-clock.patch | 31 ++ removed_splitunc.patch | 39 ++ replace-imp-with-importlib.patch | 176 ++++-- replace_TestSuite_main.patch | 713 +++++++++++++++++++++++++ scons-3.0.0-fix-install.patch | 4 +- scons-3.0.1.tar.gz | 3 - scons.changes | 15 + scons.spec | 88 ++- stop_custom_OrderedDict.patch | 162 ++++++ 14 files changed, 2010 insertions(+), 76 deletions(-) create mode 100644 3.0.1.tar.gz create mode 100644 fix-jN-for-python-37.patch create mode 100644 fix-rpm-tests-for-newer-rpmbuild.patch create mode 100644 grep-filter-list.txt create mode 100644 no_deprecated_asserts.patch create mode 100644 no_time-clock.patch create mode 100644 removed_splitunc.patch create mode 100644 replace_TestSuite_main.patch delete mode 100644 scons-3.0.1.tar.gz create mode 100644 stop_custom_OrderedDict.patch diff --git a/3.0.1.tar.gz b/3.0.1.tar.gz new file mode 100644 index 0000000..aa1880c --- /dev/null +++ b/3.0.1.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37b2d8ba2b869a397cf0007026b793230a97d6aa9545db9568755cd282dd5f53 +size 5481813 diff --git a/fix-jN-for-python-37.patch b/fix-jN-for-python-37.patch new file mode 100644 index 0000000..0ef2559 --- /dev/null +++ b/fix-jN-for-python-37.patch @@ -0,0 +1,26 @@ +--- a/src/engine/SCons/Script/Main.py ++++ b/src/engine/SCons/Script/Main.py +@@ -1253,7 +1253,11 @@ def _build_targets(fs, options, targets, + BuildTask.options = options + + +- python_has_threads = sysconfig.get_config_var('WITH_THREAD') ++ # As of 3.7, python removed support for threadless platforms. ++ # See https://www.python.org/dev/peps/pep-0011/ ++ is_37_or_later = sys.version_info.major > 3 or \ ++ sys.version_info.major == 3 and sys.version_info.minor >= 7 ++ python_has_threads = sysconfig.get_config_var('WITH_THREAD') or is_37_or_later + # to check if python configured with threads. + global num_jobs + num_jobs = options.num_jobs +--- a/runtest.py ++++ b/runtest.py +@@ -781,7 +781,7 @@ tests_passing = 0 + tests_failing = 0 + + +-def run_test(t, io_lock, async=True): ++def run_test(t, io_lock, run_async=True): + global tests_completed, tests_passing, tests_failing + header = "" + command_args = ['-tt'] diff --git a/fix-rpm-tests-for-newer-rpmbuild.patch b/fix-rpm-tests-for-newer-rpmbuild.patch new file mode 100644 index 0000000..a706eae --- /dev/null +++ b/fix-rpm-tests-for-newer-rpmbuild.patch @@ -0,0 +1,114 @@ +--- a/src/engine/SCons/Tool/packaging/rpm.py ++++ b/src/engine/SCons/Tool/packaging/rpm.py +@@ -51,10 +51,9 @@ def package(env, target, source, PACKAGE + if str(target[0])!="%s-%s"%(NAME, VERSION): + raise UserError( "Setting target is not supported for rpm." ) + else: +- # This should be overridable from the construction environment, +- # which it is by using ARCHITECTURE=. ++ # Deduce the build architecture, but allow it to be overridden ++ # by setting ARCHITECTURE in the construction env. + buildarchitecture = SCons.Tool.rpmutils.defaultMachine() +- + if 'ARCHITECTURE' in kw: + buildarchitecture = kw['ARCHITECTURE'] + +@@ -126,20 +125,18 @@ def build_specfile(target, source, env): + """ Builds a RPM specfile from a dictionary with string metadata and + by analyzing a tree of nodes. + """ +- file = open(target[0].get_abspath(), 'w') +- +- try: +- file.write( build_specfile_header(env) ) +- file.write( build_specfile_sections(env) ) +- file.write( build_specfile_filesection(env, source) ) +- file.close() +- +- # call a user specified function +- if 'CHANGE_SPECFILE' in env: +- env['CHANGE_SPECFILE'](target, source) ++ with open(target[0].get_abspath(), 'w') as file: ++ try: ++ file.write(build_specfile_header(env)) ++ file.write(build_specfile_sections(env)) ++ file.write(build_specfile_filesection(env, source)) ++ ++ # call a user specified function ++ if 'CHANGE_SPECFILE' in env: ++ env['CHANGE_SPECFILE'](target, source) + +- except KeyError as e: +- raise SCons.Errors.UserError( '"%s" package field for RPM is missing.' % e.args[0] ) ++ except KeyError as e: ++ raise SCons.Errors.UserError('"%s" package field for RPM is missing.' % e.args[0]) + + + # +@@ -201,7 +198,8 @@ def build_specfile_header(spec): + 'PACKAGEVERSION' : '%%define release %s\nRelease: %%{release}\n', + 'X_RPM_GROUP' : 'Group: %s\n', + 'SUMMARY' : 'Summary: %s\n', +- 'LICENSE' : 'License: %s\n', } ++ 'LICENSE' : 'License: %s\n', ++ } + + str = str + SimpleTagCompiler(mandatory_header_fields).compile( spec ) + +@@ -211,6 +209,7 @@ def build_specfile_header(spec): + 'X_RPM_URL' : 'Url: %s\n', + 'SOURCE_URL' : 'Source: %s\n', + 'SUMMARY_' : 'Summary(%s): %s\n', ++ 'ARCHITECTURE' : 'BuildArch: %s\n', + 'X_RPM_DISTRIBUTION' : 'Distribution: %s\n', + 'X_RPM_ICON' : 'Icon: %s\n', + 'X_RPM_PACKAGER' : 'Packager: %s\n', +@@ -229,19 +228,33 @@ def build_specfile_header(spec): + 'X_RPM_PREFIX' : 'Prefix: %s\n', + + # internal use +- 'X_RPM_BUILDROOT' : 'BuildRoot: %s\n', } ++ 'X_RPM_BUILDROOT' : 'BuildRoot: %s\n', ++ } + + # fill in default values: +- # Adding a BuildRequires renders the .rpm unbuildable under System, which ++ # Adding a BuildRequires renders the .rpm unbuildable under systems which + # are not managed by rpm, since the database to resolve this dependency is + # missing (take Gentoo as an example) +-# if not s.has_key('x_rpm_BuildRequires'): +-# s['x_rpm_BuildRequires'] = 'scons' ++ #if 'X_RPM_BUILDREQUIRES' not in spec: ++ # spec['X_RPM_BUILDREQUIRES'] = 'scons' + + if 'X_RPM_BUILDROOT' not in spec: + spec['X_RPM_BUILDROOT'] = '%{_tmppath}/%{name}-%{version}-%{release}' + + str = str + SimpleTagCompiler(optional_header_fields, mandatory=0).compile( spec ) ++ ++ # Add any extra specfile definitions the user may have supplied. ++ # These flags get no processing, they are just added. ++ # github #3164: if we don't turn off debug package generation ++ # the tests which build packages all fail. If there are no ++ # extra flags, default to adding this one. If the user wants ++ # to turn this back on, supply the flag set to None. ++ ++ if 'X_RPM_EXTRADEFS' not in spec: ++ spec['X_RPM_EXTRADEFS'] = ['%global debug_package %{nil}'] ++ for extra in spec['X_RPM_EXTRADEFS']: ++ str += extra + '\n' ++ + return str + + # +--- a/src/engine/SCons/Tool/packaging/tarbz2.py ++++ b/src/engine/SCons/Tool/packaging/tarbz2.py +@@ -32,7 +32,7 @@ from SCons.Tool.packaging import stripin + + def package(env, target, source, PACKAGEROOT, **kw): + bld = env['BUILDERS']['Tar'] +- bld.set_suffix('.tar.gz') ++ bld.set_suffix('.tar.bz2') + target, source = putintopackageroot(target, source, env, PACKAGEROOT) + target, source = stripinstallbuilder(target, source, env) + return bld(env, target, source, TARFLAGS='-jc') diff --git a/grep-filter-list.txt b/grep-filter-list.txt new file mode 100644 index 0000000..6546a84 --- /dev/null +++ b/grep-filter-list.txt @@ -0,0 +1,312 @@ +src/engine/SCons/ActionTests.py +src/engine/SCons/EnvironmentValuesTest.py +src/engine/SCons/Options/__init__.py +src/engine/SCons/Platform/aix.py +src/engine/SCons/Platform/cygwin.py +src/engine/SCons/Platform/darwin.py +src/engine/SCons/Platform/hpux.py +src/engine/SCons/Platform/irix.py +src/engine/SCons/Platform/os2.py +src/engine/SCons/Platform/sunos.py +src/engine/SCons/SConfTests.py +src/engine/SCons/Script/SConscript.py +src/engine/SCons/Script/__init__.py +src/engine/SCons/Tool/386asm.py +src/engine/SCons/Tool/MSCommon/arch.py +src/engine/SCons/Tool/MSCommon/netframework.py +src/engine/SCons/Tool/MSCommon/sdk.py +src/engine/SCons/Tool/MSCommon/vc.py +src/engine/SCons/Tool/MSCommon/vs.py +src/engine/SCons/Tool/aixcc.py +src/engine/SCons/Tool/aixf77.py +src/engine/SCons/Tool/aixlink.py +src/engine/SCons/Tool/applelink.py +src/engine/SCons/Tool/cvf.py +src/engine/SCons/Tool/cyglink.py +src/engine/SCons/Tool/docbook/docbook-xsl-1.76.1/extensions/docbook.py +src/engine/SCons/Tool/docbook/docbook-xsl-1.76.1/extensions/xslt.py +src/engine/SCons/Tool/f03.py +src/engine/SCons/Tool/f08.py +src/engine/SCons/Tool/f95.py +src/engine/SCons/Tool/gcc.py +src/engine/SCons/Tool/gfortran.py +src/engine/SCons/Tool/gnulink.py +src/engine/SCons/Tool/gxx.py +src/engine/SCons/Tool/hpcc.py +src/engine/SCons/Tool/hplink.py +src/engine/SCons/Tool/icc.py +src/engine/SCons/Tool/ifl.py +src/engine/SCons/Tool/ifort.py +src/engine/SCons/Tool/midl.py +src/engine/SCons/Tool/mslib.py +src/engine/SCons/Tool/mslink.py +src/engine/SCons/Tool/mssdk.py +src/engine/SCons/Tool/msvc.py +src/engine/SCons/Tool/msvs.py +src/engine/SCons/Tool/sgicc.py +src/engine/SCons/Tool/sgilink.py +src/engine/SCons/Tool/suncc.py +src/engine/SCons/Tool/sunf77.py +src/engine/SCons/Tool/sunf90.py +src/engine/SCons/Tool/sunf95.py +src/engine/SCons/Tool/sunlink.py +src/engine/SCons/Tool/textfile.py +src/engine/SCons/UtilTests.py +src/engine/SCons/Variables/__init__.py +src/engine/SCons/dblite.py +src/script/scons-configure-cache.py +src/script/scons-time.py +src/script/sconsign.py +src/setup.py +src/test_interrupts.py +src/test_pychecker.py +src/test_setup.py +src/test_strings.py +test/AS/fixture/myas.py +test/AS/fixture/myas_args.py +test/AS/ml.py +test/AS/nasm.py +test/Actions/pre-post-fixture/work4/build.py +test/CC/CCVERSION-fixture/versioned.py +test/CPPDEFINES/scan.py +test/Configure/implicit-cache.py +test/D/AllAtOnce/sconstest-dmd.py +test/D/AllAtOnce/sconstest-gdc.py +test/D/AllAtOnce/sconstest-ldc.py +test/D/CoreScanner/sconstest-dmd.py +test/D/CoreScanner/sconstest-gdc.py +test/D/CoreScanner/sconstest-ldc.py +test/D/DMD.py +test/D/DMD2.py +test/D/DMD2_Alt.py +test/D/GDC.py +test/D/GDC_Alt.py +test/D/HSTeoh/sconstest-arLibIssue_dmd.py +test/D/HSTeoh/sconstest-arLibIssue_gdc.py +test/D/HSTeoh/sconstest-arLibIssue_ldc.py +test/D/HSTeoh/sconstest-libCompileOptions_dmd.py +test/D/HSTeoh/sconstest-libCompileOptions_gdc.py +test/D/HSTeoh/sconstest-libCompileOptions_ldc.py +test/D/HSTeoh/sconstest-linkingProblem_dmd.py +test/D/HSTeoh/sconstest-linkingProblem_gdc.py +test/D/HSTeoh/sconstest-linkingProblem_ldc.py +test/D/HSTeoh/sconstest-singleStringCannotBeMultipleOptions_dmd.py +test/D/HSTeoh/sconstest-singleStringCannotBeMultipleOptions_gdc.py +test/D/HSTeoh/sconstest-singleStringCannotBeMultipleOptions_ldc.py +test/D/HelloWorld/CompileAndLinkOneStep/sconstest-dmd.py +test/D/HelloWorld/CompileAndLinkOneStep/sconstest-gdc.py +test/D/HelloWorld/CompileAndLinkOneStep/sconstest-ldc.py +test/D/HelloWorld/CompileThenLinkTwoSteps/sconstest-dmd.py +test/D/HelloWorld/CompileThenLinkTwoSteps/sconstest-gdc.py +test/D/HelloWorld/CompileThenLinkTwoSteps/sconstest-ldc.py +test/D/Issues/2939_Ariovistus/sconstest-correctLinkOptions_dmd.py +test/D/Issues/2939_Ariovistus/sconstest-correctLinkOptions_gdc.py +test/D/Issues/2939_Ariovistus/sconstest-correctLinkOptions_ldc.py +test/D/Issues/2940_Ariovistus/sconstest-correctLinkOptions_dmd.py +test/D/Issues/2940_Ariovistus/sconstest-correctLinkOptions_gdc.py +test/D/Issues/2940_Ariovistus/sconstest-correctLinkOptions_ldc.py +test/D/LDC.py +test/D/LDC_Alt.py +test/D/MixedDAndC/sconstest-dmd.py +test/D/MixedDAndC/sconstest-gdc.py +test/D/MixedDAndC/sconstest-ldc.py +test/D/Scanner.py +test/D/SharedObjects/sconstest-dmd.py +test/D/SharedObjects/sconstest-gdc.py +test/D/SharedObjects/sconstest-ldc.py +test/DVIPDF/makeindex.py +test/DVIPS/DVIPS.py +test/Deprecated/SourceSignatures/no-csigs.py +test/Docbook/basedir/htmlchunked/htmlchunked.py +test/Docbook/basedir/htmlchunked/htmlchunked_cmd.py +test/Docbook/basedir/htmlhelp/htmlhelp.py +test/Docbook/basedir/htmlhelp/htmlhelp_cmd.py +test/Docbook/basedir/slideshtml/slideshtml.py +test/Docbook/basedir/slideshtml/slideshtml_cmd.py +test/Docbook/basic/epub/epub_cmd.py +test/Docbook/basic/html/html_cmd.py +test/Docbook/basic/htmlchunked/htmlchunked_cmd.py +test/Docbook/basic/htmlhelp/htmlhelp_cmd.py +test/Docbook/basic/slideshtml/slideshtml.py +test/Docbook/basic/slideshtml/slideshtml_cmd.py +test/Docbook/basic/xinclude/xinclude.py +test/Docbook/dependencies/xinclude/xinclude.py +test/Docbook/rootname/htmlchunked/htmlchunked.py +test/Docbook/rootname/htmlhelp/htmlhelp.py +test/Docbook/rootname/slideshtml/slideshtml.py +test/Errors/preparation.py +test/Fortran/F77PATH.py +test/Fortran/F90PATH.py +test/Fortran/FORTRANPATH.py +test/Fortran/fixture/myfortran.py +test/Fortran/fixture/myfortran_flags.py +test/IDL/midl.py +test/Intel/icpc-link.py +test/Interactive/implicit-VariantDir.py +test/Interactive/variant_dir.py +test/Java/DerivedSourceTest.py +test/Java/JAR.py +test/Java/JARCHDIR.py +test/Java/JARFLAGS.py +test/Java/JAVABOOTCLASSPATH.py +test/Java/JAVACFLAGS.py +test/Java/JAVACLASSPATH.py +test/Java/JAVAH.py +test/Java/JAVASOURCEPATH.py +test/Java/Java-1.4.py +test/Java/Java-1.5.py +test/Java/Java-1.6.py +test/Java/RMIC.py +test/Java/multi-step.py +test/Java/nested-classes.py +test/Java/no-JARCHDIR.py +test/Java/source-files.py +test/Java/swig-dependencies.py +test/LEX/live.py +test/MSVC/MSVC_UWP_APP.py +test/MSVC/PCH-source.py +test/MSVC/PCHSTOP-errors.py +test/MSVC/TARGET_ARCH.py +test/MSVC/batch-longlines.py +test/MSVC/embed-manifest.py +test/MSVC/hierarchical.py +test/MSVC/msvc.py +test/MSVC/multiple-pdb.py +test/MSVC/pch-basics.py +test/MSVC/pch-spaces-subdir.py +test/MSVC/pdb-VariantDir-path.py +test/MSVC/pdb-manifest.py +test/MSVC/query_vcbat.py +test/MSVS/CPPPATH-Dirs.py +test/MSVS/common-prefix.py +test/MSVS/runfile.py +test/MSVS/vs-10.0-exec.py +test/MSVS/vs-10.0Exp-exec.py +test/MSVS/vs-11.0-exec.py +test/MSVS/vs-11.0Exp-exec.py +test/MSVS/vs-14.0-exec.py +test/MSVS/vs-14.0Exp-exec.py +test/MSVS/vs-6.0-exec.py +test/MSVS/vs-7.0-exec.py +test/MSVS/vs-7.1-exec.py +test/MSVS/vs-8.0-exec.py +test/MSVS/vs-8.0Exp-exec.py +test/MSVS/vs-9.0-exec.py +test/MSVS/vs-9.0Exp-exec.py +test/MinGW/MinGWSharedLibrary.py +test/MinGW/WINDOWS_INSERT_DEF.py +test/PharLap.py +test/QT/CPPPATH-appended.py +test/QT/CPPPATH.py +test/QT/QTFLAGS.py +test/QT/Tool.py +test/QT/copied-env.py +test/QT/generated-ui.py +test/QT/installed.py +test/QT/manual.py +test/QT/moc-from-header.py +test/QT/source-from-ui.py +test/QT/up-to-date.py +test/Repository/Java.py +test/Repository/JavaH.py +test/Repository/RMIC.py +test/Rpcgen/live.py +test/SConsignFile/use-dbhash.py +test/SConsignFile/use-dbm.py +test/SConsignFile/use-dumbdbm.py +test/SConsignFile/use-gdbm.py +test/SWIG/SWIG.py +test/SWIG/SWIGOUTDIR-python.py +test/SWIG/SWIGOUTDIR.py +test/SWIG/SWIGPATH.py +test/SWIG/build-dir.py +test/SWIG/generated_swigfile.py +test/SWIG/implicit-dependencies.py +test/SWIG/live.py +test/SWIG/module-deduced-name.py +test/SWIG/module-parens.py +test/SWIG/module-quoted.py +test/SWIG/module-spaces.py +test/SWIG/noproxy.py +test/SWIG/recursive-includes-cpp.py +test/SWIG/remove-modules.py +test/SWIG/subdir.py +test/TEX/PDF_single_source.py +test/TEX/TEX.py +test/TEX/auxiliaries.py +test/TEX/biber_biblatex.py +test/TEX/biber_biblatex2.py +test/TEX/biblatex.py +test/TEX/biblatex_plain.py +test/TEX/bibliography.py +test/TEX/bibtex-latex-rerun.py +test/TEX/clean.py +test/TEX/configure.py +test/TEX/dryrun.py +test/TEX/eps_graphics.py +test/TEX/eps_graphics2.py +test/TEX/generated_files.py +test/TEX/glossaries.py +test/TEX/glossary.py +test/TEX/input_docClass.py +test/TEX/lstinputlisting.py +test/TEX/makeindex.py +test/TEX/multi-line_include_options.py +test/TEX/multi-run.py +test/TEX/multibib.py +test/TEX/multiple_include.py +test/TEX/multiple_include_subdir.py +test/TEX/newglossary.py +test/TEX/nomencl.py +test/TEX/recursive_scanner_dependencies_import.py +test/TEX/recursive_scanner_dependencies_input.py +test/TEX/rename_result.py +test/TEX/subdir-as-include.py +test/TEX/subdir-input.py +test/TEX/subdir_variantdir_include.py +test/TEX/subdir_variantdir_include2.py +test/TEX/subdir_variantdir_input.py +test/TEX/synctex.py +test/TEX/usepackage.py +test/TEX/variant_dir.py +test/TEX/variant_dir_bibunit.py +test/TEX/variant_dir_dup0.py +test/TEX/variant_dir_newglossary.py +test/TEX/variant_dir_style_dup0.py +test/Win32/bad-drive.py +test/Win32/default-drive.py +test/Win32/file-is-type-not-func.py +test/Win32/mingw.py +test/Win32/scons-bat-error.py +test/Win32/win32pathmadness.py +test/YACC/YACC-fixture/myyacc.py +test/YACC/YACCFLAGS-fixture/myyacc.py +test/fixture/mycompile.py +test/fixture/mylink.py +test/fixture/myrewrite.py +test/long-lines/signature.py +test/packaging/ipkg.py +test/packaging/msi/explicit-target.py +test/packaging/msi/file-placement.py +test/packaging/msi/package.py +test/packaging/multiple-packages-at-once.py +test/packaging/option--package-type.py +test/packaging/rpm/cleanup.py +test/packaging/rpm/internationalization.py +test/packaging/rpm/multipackage.py +test/packaging/rpm/package.py +test/packaging/rpm/tagging.py +test/packaging/zip.py +test/print_statement.py +test/scons-time/run/aegis.py +test/scons-time/run/config/python.py +test/scons-time/run/option/python.py +test/sconsign/script/Configure.py +test/sconsign/script/SConsignFile.py +test/sconsign/script/Signatures.py +test/sconsign/script/bad.py +test/sconsign/script/dblite.py +test/sconsign/script/no-SConsignFile.py +test/timestamp-fallback.py +test/toolpath/relative_import/image/tools/TestTool1/TestTool1_2/__init__.py +test/toolpath/relative_import/image/tools/TestTool1/__init__.py diff --git a/no_deprecated_asserts.patch b/no_deprecated_asserts.patch new file mode 100644 index 0000000..6602bef --- /dev/null +++ b/no_deprecated_asserts.patch @@ -0,0 +1,400 @@ +From 9864e8bf0a69f6aa35bb6af794da9988b1bbc50b Mon Sep 17 00:00:00 2001 +From: Mats Wichmann +Date: Tue, 25 Sep 2018 17:48:03 -0600 +Subject: [PATCH] Stop using deprecated unittest asserts + +failUnless and failIf have been deprecated since 2.7 and 3.1, +the docs call them aliases that exist for historical reasons. +In Python 3.7, the default DeprecationWarnings make things +very noisy, so flip these to assertTrue and assertFalse. + +Signed-off-by: Mats Wichmann +--- + src/CHANGES.txt | 1 + + src/engine/SCons/JobTests.py | 70 ++++++++++++------------ + src/engine/SCons/Scanner/CTests.py | 2 +- + src/engine/SCons/Scanner/DTests.py | 2 +- + src/engine/SCons/Scanner/FortranTests.py | 2 +- + src/engine/SCons/Scanner/IDLTests.py | 2 +- + src/engine/SCons/Scanner/LaTeXTests.py | 2 +- + src/engine/SCons/Scanner/RCTests.py | 2 +- + src/engine/SCons/Scanner/ScannerTests.py | 52 +++++++++--------- + 9 files changed, 68 insertions(+), 67 deletions(-) + +--- a/src/engine/SCons/JobTests.py ++++ b/src/engine/SCons/JobTests.py +@@ -75,7 +75,7 @@ class Task(object): + return True + + def execute(self): +- self.taskmaster.test_case.failUnless(self.was_prepared, ++ self.taskmaster.test_case.assertTrue(self.was_prepared, + "the task wasn't prepared") + + self.taskmaster.guard.acquire() +@@ -93,17 +93,17 @@ class Task(object): + def executed(self): + self.taskmaster.num_executed = self.taskmaster.num_executed + 1 + +- self.taskmaster.test_case.failUnless(self.was_prepared, ++ self.taskmaster.test_case.assertTrue(self.was_prepared, + "the task wasn't prepared") +- self.taskmaster.test_case.failUnless(self.was_executed, ++ self.taskmaster.test_case.assertTrue(self.was_executed, + "the task wasn't really executed") +- self.taskmaster.test_case.failUnless(isinstance(self, Task), ++ self.taskmaster.test_case.assertTrue(isinstance(self, Task), + "the task wasn't really a Task instance") + + def failed(self): + self.taskmaster.num_failed = self.taskmaster.num_failed + 1 + self.taskmaster.stop = 1 +- self.taskmaster.test_case.failUnless(self.was_prepared, ++ self.taskmaster.test_case.assertTrue(self.was_prepared, + "the task wasn't prepared") + + def postprocess(self): +@@ -135,17 +135,17 @@ class ExceptionTask(object): + def executed(self): + self.taskmaster.num_executed = self.taskmaster.num_executed + 1 + +- self.taskmaster.test_case.failUnless(self.was_prepared, ++ self.taskmaster.test_case.assertTrue(self.was_prepared, + "the task wasn't prepared") +- self.taskmaster.test_case.failUnless(self.was_executed, ++ self.taskmaster.test_case.assertTrue(self.was_executed, + "the task wasn't really executed") +- self.taskmaster.test_case.failUnless(self.__class__ is Task, ++ self.taskmaster.test_case.assertTrue(self.__class__ is Task, + "the task wasn't really a Task instance") + + def failed(self): + self.taskmaster.num_failed = self.taskmaster.num_failed + 1 + self.taskmaster.stop = 1 +- self.taskmaster.test_case.failUnless(self.was_prepared, ++ self.taskmaster.test_case.assertTrue(self.was_prepared, + "the task wasn't prepared") + + def postprocess(self): +@@ -228,15 +228,15 @@ class ParallelTestCase(unittest.TestCase + jobs = SCons.Job.Jobs(num_jobs, taskmaster) + jobs.run() + +- self.failUnless(not taskmaster.tasks_were_serial(), ++ self.assertTrue(not taskmaster.tasks_were_serial(), + "the tasks were not executed in parallel") +- self.failUnless(taskmaster.all_tasks_are_executed(), ++ self.assertTrue(taskmaster.all_tasks_are_executed(), + "all the tests were not executed") +- self.failUnless(taskmaster.all_tasks_are_iterated(), ++ self.assertTrue(taskmaster.all_tasks_are_iterated(), + "all the tests were not iterated over") +- self.failUnless(taskmaster.all_tasks_are_postprocessed(), ++ self.assertTrue(taskmaster.all_tasks_are_postprocessed(), + "all the tests were not postprocessed") +- self.failIf(taskmaster.num_failed, ++ self.assertFalse(taskmaster.num_failed, + "some task(s) failed to execute") + + # Verify that parallel jobs will pull all of the completed tasks +@@ -291,15 +291,15 @@ class SerialTestCase(unittest.TestCase): + jobs = SCons.Job.Jobs(1, taskmaster) + jobs.run() + +- self.failUnless(taskmaster.tasks_were_serial(), ++ self.assertTrue(taskmaster.tasks_were_serial(), + "the tasks were not executed in series") +- self.failUnless(taskmaster.all_tasks_are_executed(), ++ self.assertTrue(taskmaster.all_tasks_are_executed(), + "all the tests were not executed") +- self.failUnless(taskmaster.all_tasks_are_iterated(), ++ self.assertTrue(taskmaster.all_tasks_are_iterated(), + "all the tests were not iterated over") +- self.failUnless(taskmaster.all_tasks_are_postprocessed(), ++ self.assertTrue(taskmaster.all_tasks_are_postprocessed(), + "all the tests were not postprocessed") +- self.failIf(taskmaster.num_failed, ++ self.assertFalse(taskmaster.num_failed, + "some task(s) failed to execute") + + class NoParallelTestCase(unittest.TestCase): +@@ -312,18 +312,18 @@ class NoParallelTestCase(unittest.TestCa + try: + taskmaster = Taskmaster(num_tasks, self, RandomTask) + jobs = SCons.Job.Jobs(2, taskmaster) +- self.failUnless(jobs.num_jobs == 1, ++ self.assertTrue(jobs.num_jobs == 1, + "unexpected number of jobs %d" % jobs.num_jobs) + jobs.run() +- self.failUnless(taskmaster.tasks_were_serial(), ++ self.assertTrue(taskmaster.tasks_were_serial(), + "the tasks were not executed in series") +- self.failUnless(taskmaster.all_tasks_are_executed(), ++ self.assertTrue(taskmaster.all_tasks_are_executed(), + "all the tests were not executed") +- self.failUnless(taskmaster.all_tasks_are_iterated(), ++ self.assertTrue(taskmaster.all_tasks_are_iterated(), + "all the tests were not iterated over") +- self.failUnless(taskmaster.all_tasks_are_postprocessed(), ++ self.assertTrue(taskmaster.all_tasks_are_postprocessed(), + "all the tests were not postprocessed") +- self.failIf(taskmaster.num_failed, ++ self.assertFalse(taskmaster.num_failed, + "some task(s) failed to execute") + finally: + SCons.Job.Parallel = save_Parallel +@@ -337,13 +337,13 @@ class SerialExceptionTestCase(unittest.T + jobs = SCons.Job.Jobs(1, taskmaster) + jobs.run() + +- self.failIf(taskmaster.num_executed, ++ self.assertFalse(taskmaster.num_executed, + "a task was executed") +- self.failUnless(taskmaster.num_iterated == 1, ++ self.assertTrue(taskmaster.num_iterated == 1, + "exactly one task should have been iterated") +- self.failUnless(taskmaster.num_failed == 1, ++ self.assertTrue(taskmaster.num_failed == 1, + "exactly one task should have failed") +- self.failUnless(taskmaster.num_postprocessed == 1, ++ self.assertTrue(taskmaster.num_postprocessed == 1, + "exactly one task should have been postprocessed") + + class ParallelExceptionTestCase(unittest.TestCase): +@@ -354,13 +354,13 @@ class ParallelExceptionTestCase(unittest + jobs = SCons.Job.Jobs(num_jobs, taskmaster) + jobs.run() + +- self.failIf(taskmaster.num_executed, ++ self.assertFalse(taskmaster.num_executed, + "a task was executed") +- self.failUnless(taskmaster.num_iterated >= 1, ++ self.assertTrue(taskmaster.num_iterated >= 1, + "one or more task should have been iterated") +- self.failUnless(taskmaster.num_failed >= 1, ++ self.assertTrue(taskmaster.num_failed >= 1, + "one or more tasks should have failed") +- self.failUnless(taskmaster.num_postprocessed >= 1, ++ self.assertTrue(taskmaster.num_postprocessed >= 1, + "one or more tasks should have been postprocessed") + + #--------------------------------------------------------------------- +@@ -491,10 +491,10 @@ class _SConsTaskTest(unittest.TestCase): + + for N in testnodes: + state = N.get_state() +- self.failUnless(state in [SCons.Node.no_state, N.expect_to_be], ++ self.assertTrue(state in [SCons.Node.no_state, N.expect_to_be], + "Node %s got unexpected result: %s" % (N, state)) + +- self.failUnless([N for N in testnodes if N.get_state()], ++ self.assertTrue([N for N in testnodes if N.get_state()], + "no nodes ran at all.") + + +--- a/src/engine/SCons/Scanner/CTests.py ++++ b/src/engine/SCons/Scanner/CTests.py +@@ -218,7 +218,7 @@ def deps_match(self, deps, headers): + global my_normpath + scanned = list(map(my_normpath, list(map(str, deps)))) + expect = list(map(my_normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + # define some tests: + +--- a/src/engine/SCons/Scanner/DTests.py ++++ b/src/engine/SCons/Scanner/DTests.py +@@ -80,7 +80,7 @@ def deps_match(self, deps, headers): + global my_normpath + scanned = list(map(my_normpath, list(map(str, deps)))) + expect = list(map(my_normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + """ + Examples from https://dlang.org/spec/module.html +--- a/src/engine/SCons/Scanner/FortranTests.py ++++ b/src/engine/SCons/Scanner/FortranTests.py +@@ -258,7 +258,7 @@ class DummyEnvironment(object): + def deps_match(self, deps, headers): + scanned = list(map(os.path.normpath, list(map(str, deps)))) + expect = list(map(os.path.normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + # define some tests: + +--- a/src/engine/SCons/Scanner/IDLTests.py ++++ b/src/engine/SCons/Scanner/IDLTests.py +@@ -243,7 +243,7 @@ if os.path.normcase('foo') == os.path.no + def deps_match(self, deps, headers): + scanned = list(map(my_normpath, list(map(str, deps)))) + expect = list(map(my_normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + # define some tests: + +--- a/src/engine/SCons/Scanner/LaTeXTests.py ++++ b/src/engine/SCons/Scanner/LaTeXTests.py +@@ -123,7 +123,7 @@ def deps_match(self, deps, headers): + global my_normpath + scanned = list(map(my_normpath, list(map(str, deps)))) + expect = list(map(my_normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + + class LaTeXScannerTestCase1(unittest.TestCase): +--- a/src/engine/SCons/Scanner/RCTests.py ++++ b/src/engine/SCons/Scanner/RCTests.py +@@ -117,7 +117,7 @@ if os.path.normcase('foo') == os.path.no + def deps_match(self, deps, headers): + scanned = sorted(map(my_normpath, list(map(str, deps)))) + expect = sorted(map(my_normpath, headers)) +- self.failUnless(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) ++ self.assertTrue(scanned == expect, "expect %s != scanned %s" % (expect, scanned)) + + # define some tests: + +--- a/src/engine/SCons/Scanner/ScannerTests.py ++++ b/src/engine/SCons/Scanner/ScannerTests.py +@@ -132,16 +132,16 @@ class BaseTestCase(unittest.TestCase): + scanned = scanner(filename, env, path) + scanned_strs = [str(x) for x in scanned] + +- self.failUnless(self.filename == filename, "the filename was passed incorrectly") +- self.failUnless(self.env == env, "the environment was passed incorrectly") +- self.failUnless(scanned_strs == deps, "the dependencies were returned incorrectly") ++ self.assertTrue(self.filename == filename, "the filename was passed incorrectly") ++ self.assertTrue(self.env == env, "the environment was passed incorrectly") ++ self.assertTrue(scanned_strs == deps, "the dependencies were returned incorrectly") + for d in scanned: +- self.failUnless(not isinstance(d, str), "got a string in the dependencies") ++ self.assertTrue(not isinstance(d, str), "got a string in the dependencies") + + if len(args) > 0: +- self.failUnless(self.arg == args[0], "the argument was passed incorrectly") ++ self.assertTrue(self.arg == args[0], "the argument was passed incorrectly") + else: +- self.failIf(hasattr(self, "arg"), "an argument was given when it shouldn't have been") ++ self.assertFalse(hasattr(self, "arg"), "an argument was given when it shouldn't have been") + + def test___call__dict(self): + """Test calling Scanner.Base objects with a dictionary""" +@@ -245,7 +245,7 @@ class BaseTestCase(unittest.TestCase): + dict[s] = 777 + i = hash(id(s)) + h = hash(list(dict.keys())[0]) +- self.failUnless(h == i, ++ self.assertTrue(h == i, + "hash Scanner base class expected %s, got %s" % (i, h)) + + def test_scan_check(self): +@@ -260,7 +260,7 @@ class BaseTestCase(unittest.TestCase): + self.checked = {} + path = s.path(env) + scanned = s(DummyNode('x'), env, path) +- self.failUnless(self.checked['x'] == 1, ++ self.assertTrue(self.checked['x'] == 1, + "did not call check function") + + def test_recursive(self): +@@ -269,42 +269,42 @@ class BaseTestCase(unittest.TestCase): + + s = SCons.Scanner.Base(function = self.func) + n = s.recurse_nodes(nodes) +- self.failUnless(n == [], ++ self.assertTrue(n == [], + "default behavior returned nodes: %s" % n) + + s = SCons.Scanner.Base(function = self.func, recursive = None) + n = s.recurse_nodes(nodes) +- self.failUnless(n == [], ++ self.assertTrue(n == [], + "recursive = None returned nodes: %s" % n) + + s = SCons.Scanner.Base(function = self.func, recursive = 1) + n = s.recurse_nodes(nodes) +- self.failUnless(n == n, ++ self.assertTrue(n == n, + "recursive = 1 didn't return all nodes: %s" % n) + + def odd_only(nodes): + return [n for n in nodes if n % 2] + s = SCons.Scanner.Base(function = self.func, recursive = odd_only) + n = s.recurse_nodes(nodes) +- self.failUnless(n == [1, 3], ++ self.assertTrue(n == [1, 3], + "recursive = 1 didn't return all nodes: %s" % n) + + def test_get_skeys(self): + """Test the Scanner.Base get_skeys() method""" + s = SCons.Scanner.Base(function = self.func) + sk = s.get_skeys() +- self.failUnless(sk == [], ++ self.assertTrue(sk == [], + "did not initialize to expected []") + + s = SCons.Scanner.Base(function = self.func, skeys = ['.1', '.2']) + sk = s.get_skeys() +- self.failUnless(sk == ['.1', '.2'], ++ self.assertTrue(sk == ['.1', '.2'], + "sk was %s, not ['.1', '.2']") + + s = SCons.Scanner.Base(function = self.func, skeys = '$LIST') + env = DummyEnvironment(LIST = ['.3', '.4']) + sk = s.get_skeys(env) +- self.failUnless(sk == ['.3', '.4'], ++ self.assertTrue(sk == ['.3', '.4'], + "sk was %s, not ['.3', '.4']") + + def test_select(self): +@@ -432,19 +432,19 @@ class CurrentTestCase(unittest.TestCase) + path = s.path(env) + hnb = HasNoBuilder() + s(hnb, env, path) +- self.failUnless(hnb.called_has_builder, "did not call has_builder()") +- self.failUnless(not hnb.called_is_up_to_date, "did call is_up_to_date()") +- self.failUnless(hnb.func_called, "did not call func()") ++ self.assertTrue(hnb.called_has_builder, "did not call has_builder()") ++ self.assertTrue(not hnb.called_is_up_to_date, "did call is_up_to_date()") ++ self.assertTrue(hnb.func_called, "did not call func()") + inc = IsNotCurrent() + s(inc, env, path) +- self.failUnless(inc.called_has_builder, "did not call has_builder()") +- self.failUnless(inc.called_is_up_to_date, "did not call is_up_to_date()") +- self.failUnless(not inc.func_called, "did call func()") ++ self.assertTrue(inc.called_has_builder, "did not call has_builder()") ++ self.assertTrue(inc.called_is_up_to_date, "did not call is_up_to_date()") ++ self.assertTrue(not inc.func_called, "did call func()") + ic = IsCurrent() + s(ic, env, path) +- self.failUnless(ic.called_has_builder, "did not call has_builder()") +- self.failUnless(ic.called_is_up_to_date, "did not call is_up_to_date()") +- self.failUnless(ic.func_called, "did not call func()") ++ self.assertTrue(ic.called_has_builder, "did not call has_builder()") ++ self.assertTrue(ic.called_is_up_to_date, "did not call is_up_to_date()") ++ self.assertTrue(ic.func_called, "did not call func()") + + class ClassicTestCase(unittest.TestCase): + +@@ -566,7 +566,7 @@ class ClassicTestCase(unittest.TestCase) + + s = SCons.Scanner.Classic("Test", [], None, "", function=self.func, recursive=1) + n = s.recurse_nodes(nodes) +- self.failUnless(n == n, ++ self.assertTrue(n == n, + "recursive = 1 didn't return all nodes: %s" % n) + + def odd_only(nodes): +@@ -574,7 +574,7 @@ class ClassicTestCase(unittest.TestCase) + + s = SCons.Scanner.Classic("Test", [], None, "", function=self.func, recursive=odd_only) + n = s.recurse_nodes(nodes) +- self.failUnless(n == [1, 3], ++ self.assertTrue(n == [1, 3], + "recursive = 1 didn't return all nodes: %s" % n) + + diff --git a/no_time-clock.patch b/no_time-clock.patch new file mode 100644 index 0000000..3d28f6c --- /dev/null +++ b/no_time-clock.patch @@ -0,0 +1,31 @@ +--- a/runtest.py ++++ b/runtest.py +@@ -92,8 +92,10 @@ try: + import threading + try: # python3 + from queue import Queue ++ PY3=True + except ImportError as e: # python2 + from Queue import Queue ++ PY3=False + threading_ok = True + except ImportError: + print("Can't import threading or queue") +@@ -764,10 +766,13 @@ os.environ["python_executable"] = python + # but time.time() does a better job on Linux systems, so let that be + # the non-Windows default. + +-if sys.platform == 'win32': +- time_func = time.clock +-else: +- time_func = time.time ++try: ++ time_func = time.perf_counter ++except AttributeError: ++ if sys.platform == 'win32': ++ time_func = time.clock ++ else: ++ time_func = time.time + + if print_times: + print_time_func = lambda fmt, time: sys.stdout.write(fmt % time) diff --git a/removed_splitunc.patch b/removed_splitunc.patch new file mode 100644 index 0000000..68b37c7 --- /dev/null +++ b/removed_splitunc.patch @@ -0,0 +1,39 @@ +--- a/src/engine/SCons/Node/FS.py ++++ b/src/engine/SCons/Node/FS.py +@@ -132,7 +132,10 @@ def initialize_do_splitdrive(): + global do_splitdrive + global has_unc + drive, path = os.path.splitdrive('X:/foo') +- has_unc = hasattr(os.path, 'splitunc') ++ # splitunc is removed from python 3.7 and newer ++ # so we can also just test if splitdrive works with UNC ++ has_unc = (hasattr(os.path, 'splitunc') ++ or os.path.splitdrive(r'\\split\drive\test')[0] == r'\\split\drive') + + do_splitdrive = not not drive or has_unc + +--- a/src/engine/SCons/Node/FSTests.py ++++ b/src/engine/SCons/Node/FSTests.py +@@ -605,7 +605,7 @@ class VariantDirTestCase(unittest.TestCa + print("File `%s' alter_targets() `%s' != expected `%s'" % (f, tp, expect)) + errors = errors + 1 + +- self.failIf(errors) ++ self.assertFalse(errors) + + class BaseTestCase(_tempdirTestCase): + def test_stat(self): +@@ -1657,7 +1657,12 @@ class FSTestCase(_tempdirTestCase): + import ntpath + x = test.workpath(*dirs) + drive, path = ntpath.splitdrive(x) +- unc, path = ntpath.splitunc(path) ++ try: ++ unc, path = ntpath.splitunc(path) ++ except AttributeError: ++ # could be python 3.7 or newer, make sure splitdrive can do UNC ++ assert ntpath.splitdrive(r'\\split\drive\test')[0] == r'\\split\drive' ++ pass + path = strip_slash(path) + return '//' + path[1:] + diff --git a/replace-imp-with-importlib.patch b/replace-imp-with-importlib.patch index f19323c..5c90157 100644 --- a/replace-imp-with-importlib.patch +++ b/replace-imp-with-importlib.patch @@ -1,25 +1,6 @@ -From 01a444c023fbc109d0ad1a563c80e3a98c067cb8 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Mat=C4=9Bj=20Cepl?= -Date: Wed, 25 Jul 2018 12:25:03 +0200 -Subject: [PATCH] Replace use of imp library with importlib. - -imp library has been deprecated since 3.4 and in 3.7 it finally breaks -builds. - -Presrving compatibility with python >= 2.7. ---- - src/CHANGES.txt | 3 + - src/engine/SCons/Platform/__init__.py | 13 +-- - src/engine/SCons/Script/Main.py | 95 ++++++++++++++------- - src/engine/SCons/Tool/__init__.py | 5 +- - src/engine/SCons/Tool/packaging/__init__.py | 29 +++++-- - src/engine/SCons/Util.py | 2 + - src/engine/SCons/compat/__init__.py | 8 +- - 7 files changed, 102 insertions(+), 53 deletions(-) - ---- a/engine/SCons/Platform/__init__.py -+++ b/engine/SCons/Platform/__init__.py -@@ -47,14 +47,15 @@ __revision__ = "src/engine/SCons/Platfor +--- a/src/engine/SCons/Platform/__init__.py ++++ b/src/engine/SCons/Platform/__init__.py +@@ -47,14 +47,15 @@ __revision__ = "__FILE__ __REVISION__ __ import SCons.compat @@ -60,9 +41,26 @@ Presrving compatibility with python >= 2.7. return sys.modules[full_name] def DefaultToolList(platform, env): ---- a/engine/SCons/Script/Main.py -+++ b/engine/SCons/Script/Main.py -@@ -711,54 +711,89 @@ def _load_site_scons_dir(topdir, site_di +--- a/src/engine/SCons/Script/Main.py ++++ b/src/engine/SCons/Script/Main.py +@@ -48,6 +48,7 @@ import sys + import time + import traceback + import sysconfig ++import platform + + import SCons.CacheDir + import SCons.Debug +@@ -622,7 +623,7 @@ def _SConstruct_exists(dirname='', repos + current directory. + """ + if not filelist: +- filelist = ['SConstruct', 'Sconstruct', 'sconstruct'] ++ filelist = ['SConstruct', 'Sconstruct', 'sconstruct', 'SConstruct.py', 'Sconstruct.py', 'sconstruct.py'] + for file in filelist: + sfile = os.path.join(dirname, file) + if os.path.isfile(sfile): +@@ -711,54 +712,89 @@ def _load_site_scons_dir(topdir, site_di sys.path = [os.path.abspath(site_dir)] + sys.path site_init_file = os.path.join(site_dir, site_init_filename) site_tools_dir = os.path.join(site_dir, site_tools_dirname) @@ -182,8 +180,23 @@ Presrving compatibility with python >= 2.7. if os.path.exists(site_tools_dir): # prepend to DefaultToolpath SCons.Tool.DefaultToolpath.insert(0, os.path.abspath(site_tools_dir)) ---- a/engine/SCons/Tool/__init__.py -+++ b/engine/SCons/Tool/__init__.py +@@ -1253,11 +1289,11 @@ def _build_targets(fs, options, targets, + BuildTask.options = options + + ++ is_pypy = platform.python_implementation() == 'PyPy' + # As of 3.7, python removed support for threadless platforms. + # See https://www.python.org/dev/peps/pep-0011/ +- is_37_or_later = sys.version_info.major > 3 or \ +- sys.version_info.major == 3 and sys.version_info.minor >= 7 +- python_has_threads = sysconfig.get_config_var('WITH_THREAD') or is_37_or_later ++ is_37_or_later = sys.version_info >= (3, 7) ++ python_has_threads = sysconfig.get_config_var('WITH_THREAD') or is_pypy or is_37_or_later + # to check if python configured with threads. + global num_jobs + num_jobs = options.num_jobs +--- a/src/engine/SCons/Tool/__init__.py ++++ b/src/engine/SCons/Tool/__init__.py @@ -54,6 +54,7 @@ import SCons.Scanner.D import SCons.Scanner.LaTeX import SCons.Scanner.Prog @@ -210,9 +223,13 @@ Presrving compatibility with python >= 2.7. if found_module is not None: sys.path = oldpythonpath return found_module ---- a/engine/SCons/Tool/packaging/__init__.py -+++ b/engine/SCons/Tool/packaging/__init__.py -@@ -30,10 +30,10 @@ __revision__ = "src/engine/SCons/Tool/pa +--- a/src/engine/SCons/Tool/packaging/__init__.py ++++ b/src/engine/SCons/Tool/packaging/__init__.py +@@ -27,16 +27,20 @@ SCons Packaging Tool. + + __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + ++import SCons.Defaults import SCons.Environment from SCons.Variables import * from SCons.Errors import * @@ -221,11 +238,19 @@ Presrving compatibility with python >= 2.7. from SCons.Warnings import warn, Warning -import os, imp +-import SCons.Defaults +import os - import SCons.Defaults - __all__ = [ 'src_targz', 'src_tarbz2', 'src_zip', 'tarbz2', 'targz', 'zip', 'rpm', 'msi', 'ipk' ] -@@ -63,7 +63,7 @@ def Tag(env, target, source, *more_tags, +-__all__ = [ 'src_targz', 'src_tarbz2', 'src_zip', 'tarbz2', 'targz', 'zip', 'rpm', 'msi', 'ipk' ] ++__all__ = [ ++ 'src_targz', 'src_tarbz2', 'src_xz', 'src_zip', ++ 'targz', 'tarbz2', 'xz', 'zip', ++ 'rpm', 'msi', 'ipk', ++] + + # + # Utility and Builder function +@@ -63,7 +67,7 @@ def Tag(env, target, source, *more_tags, for x in more_tags: kw_tags[x] = '' @@ -234,31 +259,64 @@ Presrving compatibility with python >= 2.7. target=[target] else: # hmm, sometimes the target list, is a list of a list -@@ -117,8 +117,21 @@ def Package(env, target=None, source=Non +@@ -102,7 +106,7 @@ def Package(env, target=None, source=Non + from SCons.Script import GetOption + kw['PACKAGETYPE'] = GetOption('package_type') + +- if kw['PACKAGETYPE'] == None: ++ if kw['PACKAGETYPE'] is None: + if 'Tar' in env['BUILDERS']: + kw['PACKAGETYPE']='targz' + elif 'Zip' in env['BUILDERS']: +@@ -117,8 +121,17 @@ def Package(env, target=None, source=Non # load the needed packagers. def load_packager(type): try: - file,path,desc=imp.find_module(type, __path__) - return imp.load_module(type, file, path, desc) -+ if PY2 or PY34: ++ if PY2: + import imp + file,path,desc=imp.find_module(type, __path__) + return imp.load_module(type, file, path, desc) + else: -+ import importlib.util, importlib.machinery -+ loader_details = ( -+ importlib.machinery.ExtensionFileLoader, -+ importlib.machinery.EXTENSION_SUFFIXES -+ ) -+ finder = importlib.machinery.FileFinder(__path__, -+ loader_details) -+ spec = finder.find_spec(type) -+ mod = importlib.util.module_from_spec(spec) -+ spec.loader.exec_module(mod) ++ import importlib ++ savepath = sys.path ++ sys.path = __path__ ++ mod = importlib.import_module(type) ++ sys.path = savepath ++ return mod except ImportError as e: raise EnvironmentError("packager %s not available: %s"%(type,str(e))) -@@ -251,12 +264,12 @@ def putintopackageroot(target, source, e +@@ -163,15 +176,22 @@ def Package(env, target=None, source=Non + # this exception means that a needed argument for the packager is + # missing. As our packagers get their "tags" as named function + # arguments we need to find out which one is missing. +- from inspect import getargspec +- args,varargs,varkw,defaults=getargspec(packager.package) +- if defaults!=None: +- args=args[:-len(defaults)] # throw away arguments with default values ++ #TODO: getargspec deprecated in Py3. cleanup when Py2.7 dropped. ++ try: ++ from inspect import getfullargspec ++ argspec = getfullargspec(packager.package) ++ except ImportError: ++ from inspect import getargspec ++ argspec = getargspec(packager.package) ++ args = argspec.args ++ if argspec.defaults: ++ # throw away arguments with default values ++ args = args[:-len(argspec.defaults)] + args.remove('env') + args.remove('target') + args.remove('source') + # now remove any args for which we have a value in kw. +- args=[x for x in args if x not in kw] ++ args = [x for x in args if x not in kw] + + if len(args)==0: + raise # must be a different error, so re-raise +@@ -251,12 +271,12 @@ def putintopackageroot(target, source, e All attributes of the source file will be copied to the new file. """ # make sure the packageroot is a Dir object. @@ -274,8 +332,22 @@ Presrving compatibility with python >= 2.7. if file.is_under(pkgroot): new_source.append(file) ---- a/engine/SCons/Util.py -+++ b/engine/SCons/Util.py +@@ -283,10 +303,9 @@ def stripinstallbuilder(target, source, + It also warns about files which have no install builder attached. + """ + def has_no_install_location(file): +- return not (file.has_builder() and\ +- hasattr(file.builder, 'name') and\ +- (file.builder.name=="InstallBuilder" or\ +- file.builder.name=="InstallAsBuilder")) ++ return not (file.has_builder() and hasattr(file.builder, 'name') ++ and file.builder.name in ["InstallBuilder", "InstallAsBuilder"]) ++ + + if len([src for src in source if has_no_install_location(src)]): + warn(Warning, "there are files to package which have no\ +--- a/src/engine/SCons/Util.py ++++ b/src/engine/SCons/Util.py @@ -35,6 +35,8 @@ import codecs import pprint @@ -284,10 +356,10 @@ Presrving compatibility with python >= 2.7. +PY34 = sys.version_info[0] == 3 and sys.version_info[1] <= 4 try: - from UserDict import UserDict ---- a/engine/SCons/compat/__init__.py -+++ b/engine/SCons/compat/__init__.py -@@ -61,7 +61,7 @@ __revision__ = "src/engine/SCons/compat/ + from collections import UserDict, UserList, UserString +--- a/src/engine/SCons/compat/__init__.py ++++ b/src/engine/SCons/compat/__init__.py +@@ -61,7 +61,7 @@ __revision__ = "__FILE__ __REVISION__ __ import os import sys diff --git a/replace_TestSuite_main.patch b/replace_TestSuite_main.patch new file mode 100644 index 0000000..2f845f9 --- /dev/null +++ b/replace_TestSuite_main.patch @@ -0,0 +1,713 @@ +--- a/src/engine/SCons/ActionTests.py ++++ b/src/engine/SCons/ActionTests.py +@@ -47,7 +47,6 @@ import SCons.Environment + import SCons.Errors + + import TestCmd +-import TestUnit + + # Initial setup of the common environment for all tests, + # a temporary working directory containing a +--- a/src/engine/SCons/CacheDirTests.py ++++ b/src/engine/SCons/CacheDirTests.py +@@ -29,7 +29,6 @@ import sys + import unittest + + from TestCmd import TestCmd +-import TestUnit + + import SCons.CacheDir + +@@ -287,16 +286,7 @@ class FileTestCase(BaseTestCase): + SCons.CacheDir.CacheRetrieveSilent = save_CacheRetrieveSilent + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- CacheDirTestCase, +- FileTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) +- ++ unittest.main() + # Local Variables: + # tab-width:4 + # indent-tabs-mode:nil +--- a/src/engine/SCons/DefaultsTests.py ++++ b/src/engine/SCons/DefaultsTests.py +@@ -32,7 +32,6 @@ import unittest + from collections import UserDict + + import TestCmd +-import TestUnit + + import SCons.Errors + +@@ -77,13 +76,7 @@ class DefaultsTestCase(unittest.TestCase + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ DefaultsTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/ErrorsTests.py ++++ b/src/engine/SCons/ErrorsTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + + +@@ -101,8 +99,7 @@ class ErrorsTestCase(unittest.TestCase): + assert e.node == "node" + + if __name__ == "__main__": +- suite = unittest.makeSuite(ErrorsTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/ExecutorTests.py ++++ b/src/engine/SCons/ExecutorTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Executor + + +@@ -483,12 +481,7 @@ class ExecutorTestCase(unittest.TestCase + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ ExecutorTestCase ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/MemoizeTests.py ++++ b/src/engine/SCons/MemoizeTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Memoize + + # Enable memoization counting +@@ -165,15 +163,7 @@ class CountValueTestCase(unittest.TestCa + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- CountDictTestCase, +- CountValueTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Node/AliasTests.py ++++ b/src/engine/SCons/Node/AliasTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Node.Alias + +@@ -113,16 +111,7 @@ class AliasBuildInfoTestCase(unittest.Te + bi = SCons.Node.Alias.AliasBuildInfo() + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- AliasTestCase, +- AliasBuildInfoTestCase, +- AliasNodeInfoTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Node/NodeTests.py ++++ b/src/engine/SCons/Node/NodeTests.py +@@ -30,8 +30,6 @@ import re + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Node + import SCons.Util +@@ -1349,15 +1347,7 @@ class NodeListTestCase(unittest.TestCase + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ BuildInfoBaseTestCase, +- NodeInfoBaseTestCase, +- NodeTestCase, +- NodeListTestCase ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Node/PythonTests.py ++++ b/src/engine/SCons/Node/PythonTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Node.Python + +@@ -113,16 +111,7 @@ class ValueBuildInfoTestCase(unittest.Te + bi = SCons.Node.Python.ValueBuildInfo() + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- ValueTestCase, +- ValueBuildInfoTestCase, +- ValueNodeInfoTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Platform/PlatformTests.py ++++ b/src/engine/SCons/Platform/PlatformTests.py +@@ -28,8 +28,6 @@ import SCons.compat + import collections + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Platform + import SCons.Environment +@@ -204,17 +202,8 @@ class PlatformEscapeTestCase(unittest.Te + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- +- tclasses = [ PlatformTestCase, +- TempFileMungeTestCase, +- PlatformEscapeTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) ++ unittest.main() + +- TestUnit.run(suite) + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/SConfTests.py ++++ b/src/engine/SCons/SConfTests.py +@@ -33,8 +33,6 @@ from types import * + import unittest + + import TestCmd +-import TestUnit +- + + sys.stdout = io.StringIO() + +--- a/src/engine/SCons/Scanner/DTests.py ++++ b/src/engine/SCons/Scanner/DTests.py +@@ -26,7 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import unittest + + import TestCmd +-import TestUnit + + import SCons.Scanner.D + +@@ -266,14 +265,7 @@ class DScannerTestCase(unittest.TestCase + self.helper('multiline.d', ['A.d']) + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- DScannerTestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Scanner/DirTests.py ++++ b/src/engine/SCons/Scanner/DirTests.py +@@ -28,7 +28,6 @@ import sys + import unittest + + import TestCmd +-import TestUnit + + import SCons.Node.FS + import SCons.Scanner.Dir +@@ -121,14 +120,8 @@ class DirEntryScannerTestCase(DirScanner + sss = list(map(str, deps)) + assert sss == [], sss + +-def suite(): +- suite = unittest.TestSuite() +- suite.addTest(DirScannerTestCase()) +- suite.addTest(DirEntryScannerTestCase()) +- return suite +- + if __name__ == "__main__": +- TestUnit.run(suite()) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Scanner/LaTeXTests.py ++++ b/src/engine/SCons/Scanner/LaTeXTests.py +@@ -31,7 +31,6 @@ import sys + import unittest + + import TestCmd +-import TestUnit + + import SCons.Node.FS + import SCons.Scanner.LaTeX +@@ -156,16 +155,8 @@ class LaTeXScannerTestCase3(unittest.Tes + files = ['inc5.xyz', 'subdir/inc4.eps'] + deps_match(self, deps, files) + +- +-def suite(): +- suite = unittest.TestSuite() +- suite.addTest(LaTeXScannerTestCase1()) +- suite.addTest(LaTeXScannerTestCase2()) +- suite.addTest(LaTeXScannerTestCase3()) +- return suite +- + if __name__ == "__main__": +- TestUnit.run(suite()) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Scanner/ProgTests.py ++++ b/src/engine/SCons/Scanner/ProgTests.py +@@ -28,7 +28,6 @@ import sys + import unittest + + import TestCmd +-import TestUnit + + import SCons.Node.FS + import SCons.Scanner.Prog +@@ -274,7 +273,7 @@ def suite(): + return suite + + if __name__ == "__main__": +- TestUnit.run(suite()) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Scanner/RCTests.py ++++ b/src/engine/SCons/Scanner/RCTests.py +@@ -29,7 +29,6 @@ import collections + import os + + import TestCmd +-import TestUnit + + import SCons.Scanner.RC + import SCons.Node.FS +@@ -167,7 +166,7 @@ def suite(): + return suite + + if __name__ == "__main__": +- TestUnit.run(suite()) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Script/MainTests.py ++++ b/src/engine/SCons/Script/MainTests.py +@@ -25,8 +25,6 @@ __revision__ = "__FILE__ __REVISION__ __ + + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Script.Main + +@@ -41,12 +39,7 @@ import SCons.Script.Main + # of private functionality. + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/SubstTests.py ++++ b/src/engine/SCons/SubstTests.py +@@ -32,8 +32,6 @@ import unittest + + from collections import UserDict + +-import TestUnit +- + import SCons.Errors + + from SCons.Subst import * +@@ -1243,21 +1241,7 @@ class subst_dict_TestCase(unittest.TestC + assert SOURCES == ['s3', 'v-rstr-s4', 'v-s5'], SOURCES + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ +- CLVar_TestCase, +- LiteralTestCase, +- SpecialAttrWrapperTestCase, +- quote_spaces_TestCase, +- scons_subst_TestCase, +- scons_subst_list_TestCase, +- scons_subst_once_TestCase, +- subst_dict_TestCase, +- ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/TaskmasterTests.py ++++ b/src/engine/SCons/TaskmasterTests.py +@@ -30,7 +30,6 @@ import copy + import sys + import unittest + +-import TestUnit + + import SCons.Taskmaster + import SCons.Errors +@@ -1239,8 +1238,7 @@ Taskmaster: No candidate anymore. + + + if __name__ == "__main__": +- suite = unittest.makeSuite(TaskmasterTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Tool/JavaCommonTests.py ++++ b/src/engine/SCons/Tool/JavaCommonTests.py +@@ -27,8 +27,6 @@ import os.path + import sys + import unittest + +-import TestUnit +- + import SCons.Scanner.IDL + import SCons.Tool.JavaCommon + +@@ -568,12 +566,7 @@ public class Foo + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ parse_javaTestCase ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Tool/javacTests.py ++++ b/src/engine/SCons/Tool/javacTests.py +@@ -24,8 +24,6 @@ + import os + import unittest + +-import TestUnit +- + import SCons.Tool.javac + + class DummyNode(object): +@@ -40,14 +38,14 @@ class pathoptTestCase(unittest.TestCase) + popt = SCons.Tool.javac.pathopt('-foopath', 'FOOPATH') + env = {'FOOPATH': path} + actual = popt(None, None, env, None) +- self.assertEquals(expect, actual) ++ self.assertEqual(expect, actual) + + def assert_pathopt_default(self, expect, path, default): + popt = SCons.Tool.javac.pathopt('-foopath', 'FOOPATH', default='DPATH') + env = {'FOOPATH': path, + 'DPATH': default} + actual = popt(None, None, env, None) +- self.assertEquals(expect, actual) ++ self.assertEqual(expect, actual) + + def test_unset(self): + self.assert_pathopt([], None) +@@ -101,5 +99,4 @@ class pathoptTestCase(unittest.TestCase) + '') + + if __name__ == "__main__": +- suite = unittest.makeSuite(pathoptTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() +--- a/src/engine/SCons/Tool/wixTests.py ++++ b/src/engine/SCons/Tool/wixTests.py +@@ -33,7 +33,6 @@ from SCons.Tool.wix import * + from SCons.Environment import Environment + + import TestCmd +-import TestUnit + + + # create fake candle and light, so the tool's exists() method will succeed +@@ -53,8 +52,7 @@ class WixTestCase(unittest.TestCase): + assert env.subst('$WIXSRCSUF') == '.wxs' + + if __name__ == "__main__": +- suite = unittest.makeSuite(WixTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/UtilTests.py ++++ b/src/engine/SCons/UtilTests.py +@@ -32,7 +32,6 @@ import unittest + from collections import UserDict, UserList, UserString + + import TestCmd +-import TestUnit + + import SCons.Errors + +--- a/src/engine/SCons/Variables/BoolVariableTests.py ++++ b/src/engine/SCons/Variables/BoolVariableTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Variables + +@@ -118,8 +116,7 @@ class BoolVariableTestCase(unittest.Test + + + if __name__ == "__main__": +- suite = unittest.makeSuite(BoolVariableTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Variables/EnumVariableTests.py ++++ b/src/engine/SCons/Variables/EnumVariableTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Variables + +@@ -195,8 +193,7 @@ class EnumVariableTestCase(unittest.Test + + + if __name__ == "__main__": +- suite = unittest.makeSuite(EnumVariableTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Variables/ListVariableTests.py ++++ b/src/engine/SCons/Variables/ListVariableTests.py +@@ -27,8 +27,6 @@ import copy + import sys + import unittest + +-import TestUnit +- + import SCons.Errors + import SCons.Variables + +@@ -125,8 +123,7 @@ class ListVariableTestCase(unittest.Test + n = l.__class__(copy.copy(l)) + + if __name__ == "__main__": +- suite = unittest.makeSuite(ListVariableTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Variables/PackageVariableTests.py ++++ b/src/engine/SCons/Variables/PackageVariableTests.py +@@ -30,8 +30,6 @@ import SCons.Errors + import SCons.Variables + + import TestCmd +-import TestUnit +- + + class PackageVariableTestCase(unittest.TestCase): + def test_PackageVariable(self): +@@ -115,8 +113,7 @@ class PackageVariableTestCase(unittest.T + + + if __name__ == "__main__": +- suite = unittest.makeSuite(PackageVariableTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Variables/PathVariableTests.py ++++ b/src/engine/SCons/Variables/PathVariableTests.py +@@ -31,8 +31,6 @@ import SCons.Errors + import SCons.Variables + + import TestCmd +-import TestUnit +- + + class PathVariableTestCase(unittest.TestCase): + def test_PathVariable(self): +@@ -228,8 +226,7 @@ class PathVariableTestCase(unittest.Test + + + if __name__ == "__main__": +- suite = unittest.makeSuite(PathVariableTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/Variables/VariablesTests.py ++++ b/src/engine/SCons/Variables/VariablesTests.py +@@ -27,7 +27,6 @@ import sys + import unittest + + import TestSCons +-import TestUnit + + import SCons.Variables + import SCons.Subst +@@ -60,7 +59,9 @@ def check(key, value, env): + def checkSave(file, expected): + gdict = {} + ldict = {} +- exec(open(file, 'r').read(), gdict, ldict) ++ with open(file, 'r') as f: ++ exec(f.read(), gdict, ldict) ++ + assert expected == ldict, "%s\n...not equal to...\n%s" % (expected, ldict) + + class VariablesTestCase(unittest.TestCase): +@@ -690,13 +691,7 @@ class UnknownVariablesTestCase(unittest. + + + if __name__ == "__main__": +- suite = unittest.TestSuite() +- tclasses = [ VariablesTestCase, +- UnknownVariablesTestCase ] +- for tclass in tclasses: +- names = unittest.getTestCaseNames(tclass, 'test_') +- suite.addTests(list(map(tclass, names))) +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 +--- a/src/engine/SCons/WarningsTests.py ++++ b/src/engine/SCons/WarningsTests.py +@@ -26,8 +26,6 @@ __revision__ = "__FILE__ __REVISION__ __ + import sys + import unittest + +-import TestUnit +- + import SCons.Warnings + + class TestOutput(object): +@@ -127,8 +125,7 @@ class WarningsTestCase(unittest.TestCase + assert to.out == "Foo", to.out + + if __name__ == "__main__": +- suite = unittest.makeSuite(WarningsTestCase, 'test_') +- TestUnit.run(suite) ++ unittest.main() + + # Local Variables: + # tab-width:4 diff --git a/scons-3.0.0-fix-install.patch b/scons-3.0.0-fix-install.patch index e2fbdfa..6dda448 100644 --- a/scons-3.0.0-fix-install.patch +++ b/scons-3.0.0-fix-install.patch @@ -2,8 +2,8 @@ setup.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) ---- a/setup.py -+++ b/setup.py +--- a/src/setup.py ++++ b/src/setup.py @@ -376,7 +376,7 @@ class install_data(_install_data): if is_win32: dir = 'Doc' diff --git a/scons-3.0.1.tar.gz b/scons-3.0.1.tar.gz deleted file mode 100644 index 396bd0c..0000000 --- a/scons-3.0.1.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:24475e38d39c19683bc88054524df018fe6949d70fbd4c69e298d39a0269f173 -size 634815 diff --git a/scons.changes b/scons.changes index 3e53a68..9cf54c0 100644 --- a/scons.changes +++ b/scons.changes @@ -1,3 +1,18 @@ +------------------------------------------------------------------- +Fri Oct 5 01:35:18 CEST 2018 - mcepl@suse.com + +- Block failing tests (and block %check section completely on + non-Intel archs, as the tests are apparently not designed for + that). +- FIx patches from the upstream to improve compatbiilty: + fix-jN-for-python-37.patch + fix-rpm-tests-for-newer-rpmbuild.patch + no_deprecated_asserts.patch + no_time-clock.patch + removed_splitunc.patch + replace_TestSuite_main.patch + stop_custom_OrderedDict.patch + ------------------------------------------------------------------- Wed Jul 25 12:10:25 UTC 2018 - mcepl@suse.com diff --git a/scons.spec b/scons.spec index bdc2918..f94ea65 100644 --- a/scons.spec +++ b/scons.spec @@ -12,7 +12,7 @@ # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# Please submit bugfixes or comments via https://bugs.opensuse.org/ # @@ -23,15 +23,46 @@ Summary: Replacement for Make License: MIT Group: Development/Tools/Building URL: http://www.scons.org/ -Source0: http://prdownloads.sourceforge.net/scons/%{name}-%{version}.tar.gz +Source0: https://github.com/SCons/%{name}/archive/%{version}.tar.gz #http://www.scons.org/doc/%%{version}/HTML/scons-user.html Source1: scons-user.html-%{version}.tar.bz2 -# Sets _mandir to _datadir/man instead of _prefix/man -Patch0: %{name}-3.0.0-fix-install.patch -Patch1: replace-imp-with-importlib.patch -BuildRequires: fdupes -BuildRequires: python3-devel >= 3.5 +# Adjust to exclude all failing tests +Source2: grep-filter-list.txt +# Upstream compatibilitt patches +Patch0: no_deprecated_asserts.patch +Patch1: removed_splitunc.patch +Patch2: fix-jN-for-python-37.patch +Patch3: replace_TestSuite_main.patch +Patch4: stop_custom_OrderedDict.patch +Patch5: no_time-clock.patch +# Specific fixes +Patch6: fix-rpm-tests-for-newer-rpmbuild.patch +# Patch7: replace-imp-with-importlib.patch +# Local modification +Patch8: scons-3.0.0-fix-install.patch +BuildRequires: grep +BuildRequires: python3-base >= 3.5 +BuildRequires: python3-lxml Requires: python3-base >= 3.5 +# For tests +BuildRequires: clang +BuildRequires: docbook-xsl-pdf2index +BuildRequires: docbook5-xsl-stylesheets +BuildRequires: gcc-c++ +BuildRequires: libxml2-devel +BuildRequires: libxslt-devel +BuildRequires: libxslt-tools +BuildRequires: xmlgraphics-fop +# texlive texlive-latex3 biber texmaker ghostscript +BuildRequires: autoconf +BuildRequires: automake +BuildRequires: bison +BuildRequires: git +BuildRequires: libtool +BuildRequires: pcre-devel +BuildRequires: subversion +BuildRequires: swig + BuildArch: noarch %description @@ -42,27 +73,46 @@ provides itself as well as the features. SCons allows you to use the full power of Python to control compilation. %prep -%setup -q -a1 -%patch0 -p1 -%patch1 -p1 +%setup -q +%autopatch -p1 -sed -i -e '/QT_LIBPATH = os.path.join.*QTDIR/s/lib/%{_lib}/' engine/SCons/Tool/qt.py +sed -i -e '/QT_LIBPATH = os.path.join.*QTDIR/s/lib/%{_lib}/' \ + src/engine/SCons/Tool/qt.py +sed -i 's|%{_bindir}/env python|%{_bindir}/python3|' src/script/* -sed -i 's|%{_bindir}/env python|%{_bindir}/python3|' script/* +cp %{SOURCE2} grep-filter-list.txt %build -export CFLAGS="%{optflags}" -%python3_build +python3 bootstrap.py build/scons +cd build/scons +%py3_build %install -%python3_install -%fdupes %{buildroot}%{_bindir} +cd build/scons +ls -lh build/lib +%py3_install \ + --standard-lib \ + --no-install-bat \ + --no-version-script \ + --install-scripts=%{_bindir} \ + --record installed_files.txt + +%check +# Tests on non-Intel archs have too many failing tests +%ifarch i586 x86_64 +TEMP_FILE=$(mktemp --tmpdir scons-test.XXXXXX) +trap 'rm -f -- "$TEMP_FILE"' INT TERM HUP EXIT +find src/ test/ -name \*.py \ + | grep -F -v -f grep-filter-list.txt >$TEMP_FILE +python3 runtest.py -f $TEMP_FILE +%endif %files -%license LICENSE.txt -%doc CHANGES.txt README.txt RELEASE.txt scons-user.html +%license LICENSE +%doc src/CHANGES.txt README.rst src/RELEASE.txt %{_bindir}/* -%{_libexecdir}/scons-%{version} +%{python3_sitelib}/SCons +%{python3_sitelib}/scons*.egg-info %{_mandir}/man1/*%{ext_man} %changelog diff --git a/stop_custom_OrderedDict.patch b/stop_custom_OrderedDict.patch new file mode 100644 index 0000000..79cb72c --- /dev/null +++ b/stop_custom_OrderedDict.patch @@ -0,0 +1,162 @@ +From 2180ff6d0388162586fff59e066bc1e3e4bb9600 Mon Sep 17 00:00:00 2001 +From: Mats Wichmann +Date: Sun, 26 Aug 2018 22:54:00 -0600 +Subject: [PATCH] Stop using custom OrderedDict + +OrdredDict is in the standard library for all supported Python versions +(2.7 and 3.5+) and has improvements over the ActiveState recipe version +of OrderedDict we have been using. Switch to importing from collections +instead of getting it from SCons.Util (tests already did this). + +At the same time, reorganize the Util.py imports - import Iterable +from collections.abc if possible (it is deprecated to import +it from collections, will stop working in 3.8); try getting the +User{Dict,List,String} from collections if possible - that is, try the +3.x way first. + +Signed-off-by: Mats Wichmann +--- + src/engine/SCons/Action.py | 3 +- + src/engine/SCons/Tool/javac.py | 3 +- + src/engine/SCons/Util.py | 74 +++++----------------------------- + 3 files changed, 13 insertions(+), 67 deletions(-) + +--- a/src/engine/SCons/Action.py ++++ b/src/engine/SCons/Action.py +@@ -107,6 +107,7 @@ import sys + import subprocess + import itertools + import inspect ++from collections import OrderedDict + + import SCons.Debug + from SCons.Debug import logInstanceCreation +@@ -1289,7 +1290,7 @@ class ListAction(ActionBase): + return result + + def get_varlist(self, target, source, env, executor=None): +- result = SCons.Util.OrderedDict() ++ result = OrderedDict() + for act in self.list: + for var in act.get_varlist(target, source, env, executor): + result[var] = True +--- a/src/engine/SCons/Tool/javac.py ++++ b/src/engine/SCons/Tool/javac.py +@@ -34,6 +34,7 @@ __revision__ = "__FILE__ __REVISION__ __ + + import os + import os.path ++from collections import OrderedDict + + import SCons.Action + import SCons.Builder +@@ -70,7 +71,7 @@ def emit_java_classes(target, source, en + if isinstance(entry, SCons.Node.FS.File): + slist.append(entry) + elif isinstance(entry, SCons.Node.FS.Dir): +- result = SCons.Util.OrderedDict() ++ result = OrderedDict() + dirnode = entry.rdir() + def find_java_files(arg, dirpath, filenames): + java_files = sorted([n for n in filenames +--- a/src/engine/SCons/Util.py ++++ b/src/engine/SCons/Util.py +@@ -37,21 +37,18 @@ import pprint + PY3 = sys.version_info[0] == 3 + + try: ++ from collections import UserDict, UserList, UserString ++except ImportError: + from UserDict import UserDict +-except ImportError as e: +- from collections import UserDict +- +-try: + from UserList import UserList +-except ImportError as e: +- from collections import UserList +- +-from collections import Iterable ++ from UserString import UserString + + try: +- from UserString import UserString +-except ImportError as e: +- from collections import UserString ++ from collections.abc import Iterable ++except ImportError: ++ from collections import Iterable ++ ++from collections import OrderedDict + + # Don't "from types import ..." these because we need to get at the + # types module later to look for UnicodeType. +@@ -63,7 +60,7 @@ MethodType = types.MethodType + FunctionType = types.FunctionType + + try: +- unicode ++ _ = type(unicode) + except NameError: + UnicodeType = str + else: +@@ -1034,59 +1031,6 @@ class CLVar(UserList): + def __str__(self): + return ' '.join(self.data) + +-# A dictionary that preserves the order in which items are added. +-# Submitted by David Benjamin to ActiveState's Python Cookbook web site: +-# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/107747 +-# Including fixes/enhancements from the follow-on discussions. +-class OrderedDict(UserDict): +- def __init__(self, dict = None): +- self._keys = [] +- UserDict.__init__(self, dict) +- +- def __delitem__(self, key): +- UserDict.__delitem__(self, key) +- self._keys.remove(key) +- +- def __setitem__(self, key, item): +- UserDict.__setitem__(self, key, item) +- if key not in self._keys: self._keys.append(key) +- +- def clear(self): +- UserDict.clear(self) +- self._keys = [] +- +- def copy(self): +- dict = OrderedDict() +- dict.update(self) +- return dict +- +- def items(self): +- return list(zip(self._keys, list(self.values()))) +- +- def keys(self): +- return self._keys[:] +- +- def popitem(self): +- try: +- key = self._keys[-1] +- except IndexError: +- raise KeyError('dictionary is empty') +- +- val = self[key] +- del self[key] +- +- return (key, val) +- +- def setdefault(self, key, failobj = None): +- UserDict.setdefault(self, key, failobj) +- if key not in self._keys: self._keys.append(key) +- +- def update(self, dict): +- for (key, val) in dict.items(): +- self.__setitem__(key, val) +- +- def values(self): +- return list(map(self.get, self._keys)) + + class Selector(OrderedDict): + """A callable ordered dictionary that maps file suffixes to