SCons/ActionTests.py

   1 # MIT License
   2 #
   3 # Copyright The SCons Foundation
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining
   6 # a copy of this software and associated documentation files (the
   7 # "Software"), to deal in the Software without restriction, including
   8 # without limitation the rights to use, copy, modify, merge, publish,
   9 # distribute, sublicense, and/or sell copies of the Software, and to
  10 # permit persons to whom the Software is furnished to do so, subject to
  11 # the following conditions:
  12 #
  13 # The above copyright notice and this permission notice shall be included
  14 # in all copies or substantial portions of the Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  17 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  18 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23 #
  24
  25 # Define a null function and a null class for use as builder actions.
  26 # Where these are defined in the file seems to affect their byte-code
  27 # contents, so try to minimize changes by defining them here, before we
  28 # even import anything.
  29
  30 from __future__ import annotations
  31
  32 def GlobalFunc() -> None:
  33     pass
  34
  35
  36 class GlobalActFunc:
  37     def __call__(self) -> None:
  38         pass
  39
  40
  41 import io
  42 import os
  43 import sys
  44 import types
  45 import unittest
  46 from unittest import mock
  47 from subprocess import PIPE
  48 from typing import TYPE_CHECKING
  49
  50 import SCons.Action
  51 import SCons.Environment
  52 import SCons.Errors
  53 from SCons.Action import scons_subproc_run
  54
  55 if TYPE_CHECKING:
  56     from SCons.Executor import Executor
  57
  58 import TestCmd
  59
  60 # Initial setup of the common environment for all tests,
  61 # a temporary working directory containing a
  62 # script for writing arguments to an output file.
  63 #
  64 # We don't do this as a setUp() method because it's
  65 # unnecessary to create a separate directory and script
  66 # for each test, they can just use the one.
  67 test = TestCmd.TestCmd(workdir='')
  68
  69 test.write('act.py', """\
  70 import os, string, sys
  71
  72 with open(sys.argv[1], 'w') as f:
  73     f.write("act.py: '" + "' '".join(sys.argv[2:]) + "'\\n")
  74     try:
  75         if sys.argv[3]:
  76             f.write("act.py: '" + os.environ[sys.argv[3]] + "'\\n")
  77     except:
  78         pass
  79
  80 if 'ACTPY_PIPE' in os.environ:
  81     if 'PIPE_STDOUT_FILE' in os.environ:
  82         with open(os.environ['PIPE_STDOUT_FILE'], 'r') as f:
  83             stdout_msg = f.read()
  84     else:
  85         stdout_msg = "act.py: stdout: executed act.py %s\\n" % ' '.join(sys.argv[1:])
  86     sys.stdout.write(stdout_msg)
  87     if 'PIPE_STDERR_FILE' in os.environ:
  88         with open(os.environ['PIPE_STDERR_FILE'], 'r') as f:
  89             stderr_msg = f.read()
  90     else:
  91         stderr_msg = "act.py: stderr: executed act.py %s\\n" % ' '.join(sys.argv[1:])
  92     sys.stderr.write(stderr_msg)
  93 sys.exit(0)
  94 """)
  95
  96 test.write('exit.py', """\
  97 import sys
  98 sys.exit(int(sys.argv[1]))
  99 """)
 100
 101 act_py = test.workpath('act.py')
 102 exit_py = test.workpath('exit.py')
 103
 104 outfile = test.workpath('outfile')
 105 outfile2 = test.workpath('outfile2')
 106 pipe_file = test.workpath('pipe.out')
 107
 108 scons_env = SCons.Environment.Environment()
 109
 110 # Capture all the stuff the Actions will print,
 111 # so it doesn't clutter the output.
 112 sys.stdout = io.StringIO()
 113
 114
 115 class CmdStringHolder:
 116     def __init__(self, cmd, literal=None) -> None:
 117         self.data = str(cmd)
 118         self.literal = literal
 119
 120     def is_literal(self) -> bool:
 121         return self.literal
 122
 123     def escape(self, escape_func):
 124         """Escape the string with the supplied function.
 125
 126         The function is expected to take an arbitrary string, then
 127         return it with all special characters escaped and ready
 128         for passing to the command interpreter.
 129
 130         After calling this function, the next call to str() will
 131         return the escaped string.
 132         """
 133
 134         if self.is_literal():
 135             return escape_func(self.data)
 136         elif ' ' in self.data or '\t' in self.data:
 137             return '"%s"' % self.data
 138         else:
 139             return self.data
 140
 141
 142 class Environment:
 143     def __init__(self, **kw) -> None:
 144         self.d = {}
 145         self.d['SHELL'] = scons_env['SHELL']
 146         self.d['SPAWN'] = scons_env['SPAWN']
 147         self.d['PSPAWN'] = scons_env['PSPAWN']
 148         self.d['ESCAPE'] = scons_env['ESCAPE']
 149         for k, v in kw.items():
 150             self.d[k] = v
 151
 152     # Just use the underlying scons_subst*() utility methods.
 153     def subst(self, strSubst, raw: int=0, target=[], source=[], conv=None, overrides: bool=False):
 154         return SCons.Subst.scons_subst(strSubst, self, raw,
 155                                        target, source, self.d, conv=conv, overrides=overrides)
 156
 157     subst_target_source = subst
 158
 159     def subst_list(self, strSubst, raw: int=0, target=[], source=[], conv=None, overrides: bool=False):
 160         return SCons.Subst.scons_subst_list(strSubst, self, raw,
 161                                             target, source, self.d, conv=conv, overrides=overrides)
 162
 163     def __getitem__(self, item):
 164         return self.d[item]
 165
 166     def __setitem__(self, item, value) -> None:
 167         self.d[item] = value
 168
 169     def __contains__(self, key) -> bool:
 170         return key in self.d
 171
 172     def get(self, key, value=None):
 173         return self.d.get(key, value)
 174
 175     def items(self):
 176         return list(self.d.items())
 177
 178     def Dictionary(self):
 179         return self.d
 180
 181     def Clone(self, **kw):
 182         res = Environment()
 183         res.d = SCons.Util.semi_deepcopy(self.d)
 184         for k, v in kw.items():
 185             res.d[k] = v
 186         return res
 187
 188     def sig_dict(self):
 189         d = {}
 190         for k, v in self.items(): d[k] = v
 191         d['TARGETS'] = ['__t1__', '__t2__', '__t3__', '__t4__', '__t5__', '__t6__']
 192         d['TARGET'] = d['TARGETS'][0]
 193         d['SOURCES'] = ['__s1__', '__s2__', '__s3__', '__s4__', '__s5__', '__s6__']
 194         d['SOURCE'] = d['SOURCES'][0]
 195         return d
 196
 197
 198 class DummyNode:
 199     def __init__(self, name) -> None:
 200         self.name = name
 201
 202     def str_for_display(self):
 203         return '"' + self.name + '"'
 204
 205     def __str__(self) -> str:
 206         return self.name
 207
 208     def rfile(self):
 209         return self
 210
 211     def get_subst_proxy(self):
 212         return self
 213
 214
 215 if os.name == 'java':
 216     python = os.path.join(sys.prefix, 'jython')
 217 else:
 218     python = os.environ.get('python_executable', sys.executable)
 219 _python_ = test.escape(python)
 220
 221 _null = SCons.Action._null
 222
 223
 224 def test_varlist(pos_call, str_call, cmd, cmdstrfunc, **kw) -> None:
 225     def call_action(a, pos_call=pos_call, str_call=str_call, kw=kw):
 226         a = SCons.Action.Action(*a, **kw)
 227         # returned object must provide these entry points
 228         assert hasattr(a, '__call__')
 229         assert hasattr(a, 'get_contents')
 230         assert hasattr(a, 'genstring')
 231         pos_call(a)
 232         str_call(a)
 233         return a
 234
 235     a = call_action((cmd, cmdstrfunc))
 236     assert a.varlist == (), a.varlist
 237
 238     a = call_action((cmd, cmdstrfunc, 'foo'))
 239     assert a.varlist == ('foo',), a.varlist
 240
 241     a = call_action((cmd, cmdstrfunc, 'a', 'b', 'c'))
 242     assert a.varlist == ('a', 'b', 'c'), a.varlist
 243
 244     a = call_action((cmd, cmdstrfunc, ['a', 'b', 'c']))
 245     assert a.varlist == ('a', 'b', 'c'), a.varlist
 246
 247     kw['varlist'] = 'foo'
 248     a = call_action((cmd, cmdstrfunc))
 249     assert a.varlist == ('foo',), a.varlist
 250
 251     kw['varlist'] = ['x', 'y', 'z']
 252     a = call_action((cmd, cmdstrfunc))
 253     assert a.varlist == ('x', 'y', 'z'), a.varlist
 254
 255     a = call_action((cmd, cmdstrfunc, 'foo'))
 256     assert a.varlist == ('foo', 'x', 'y', 'z'), a.varlist
 257
 258     a = call_action((cmd, cmdstrfunc, 'a', 'b', 'c'))
 259     assert a.varlist == ('a', 'b', 'c', 'x', 'y', 'z'), a.varlist
 260
 261
 262 def test_positional_args(pos_callback, cmd, **kw):
 263     """Test that Action returns the expected type and positional args work."""
 264
 265     act = SCons.Action.Action(cmd, **kw)
 266     pos_callback(act)
 267     assert act.varlist == (), act.varlist
 268
 269     if not isinstance(act, SCons.Action._ActionAction):
 270         # only valid cmdstrfunc is None
 271         def none(a) -> None:
 272             pass
 273
 274         test_varlist(pos_callback, none, cmd, None, **kw)
 275     else:
 276         # _ActionAction should have set these
 277         assert hasattr(act, 'strfunction')
 278         assert act.cmdstr is _null, act.cmdstr
 279         assert act.presub is _null, act.presub
 280         assert act.chdir is None, act.chdir
 281         assert act.exitstatfunc is SCons.Action.default_exitstatfunc, \
 282             act.exitstatfunc
 283
 284         def cmdstr(a) -> None:
 285             assert hasattr(a, 'strfunction')
 286             assert a.cmdstr == 'cmdstr', a.cmdstr
 287
 288         test_varlist(pos_callback, cmdstr, cmd, 'cmdstr', **kw)
 289
 290         def fun() -> None:
 291             pass
 292
 293         def strfun(a, fun=fun) -> None:
 294             assert a.strfunction is fun, a.strfunction
 295             assert a.cmdstr == _null, a.cmdstr
 296
 297         test_varlist(pos_callback, strfun, cmd, fun, **kw)
 298
 299         def none(a) -> None:
 300             assert hasattr(a, 'strfunction')
 301             assert a.cmdstr is None, a.cmdstr
 302
 303         test_varlist(pos_callback, none, cmd, None, **kw)
 304
 305         # Test handling of bad cmdstrfunc arguments
 306         try:
 307             a = SCons.Action.Action(cmd, [], **kw)
 308         except SCons.Errors.UserError as e:
 309             s = str(e)
 310             m = 'Invalid command display variable'
 311             assert s.find(m) != -1, 'Unexpected string:  %s' % s
 312         else:
 313             raise Exception("did not catch expected UserError")
 314
 315     return act
 316
 317
 318 class ActionTestCase(unittest.TestCase):
 319     """Test the Action() factory function"""
 320
 321     def test_FunctionAction(self) -> None:
 322         """Test the Action() factory's creation of FunctionAction objects."""
 323
 324         def foo() -> None:
 325             pass
 326
 327         def func_action(a, foo=foo) -> None:
 328             assert isinstance(a, SCons.Action.FunctionAction), a
 329             assert a.execfunction == foo, a.execfunction
 330
 331         test_positional_args(func_action, foo)
 332         # a singleton list returns the contained action
 333         test_positional_args(func_action, [foo])
 334
 335     def test_CommandAction(self) -> None:
 336         """Test the Action() factory's creation of CommandAction objects."""
 337
 338         def cmd_action(a) -> None:
 339             assert isinstance(a, SCons.Action.CommandAction), a
 340             assert a.cmd_list == "string", a.cmd_list
 341
 342         test_positional_args(cmd_action, "string")
 343         # a singleton list returns the contained action
 344         test_positional_args(cmd_action, ["string"])
 345
 346         def line_action(a) -> None:
 347             assert isinstance(a, SCons.Action.CommandAction), a
 348             assert a.cmd_list == ["explicit", "command", "line"], a.cmd_list
 349
 350         test_positional_args(line_action, [["explicit", "command", "line"]])
 351
 352     def test_ListAction(self) -> None:
 353         """Test the Action() factory's creation of ListAction objects."""
 354
 355         a1 = SCons.Action.Action(["x", "y", "z", ["a", "b", "c"]])
 356         assert isinstance(a1, SCons.Action.ListAction), f"a1 is {type(a1)}"
 357         assert a1.varlist == (), a1.varlist
 358         assert isinstance(a1.list[0], SCons.Action.CommandAction), a1.list[0]
 359         assert a1.list[0].cmd_list == "x", a1.list[0].cmd_list
 360         assert isinstance(a1.list[1], SCons.Action.CommandAction), a1.list[1]
 361         assert a1.list[1].cmd_list == "y", a1.list[1].cmd_list
 362         assert isinstance(a1.list[2], SCons.Action.CommandAction), a1.list[2]
 363         assert a1.list[2].cmd_list == "z", a1.list[2].cmd_list
 364         assert isinstance(a1.list[3], SCons.Action.CommandAction), a1.list[3]
 365         assert a1.list[3].cmd_list == ["a", "b", "c"], a1.list[3].cmd_list
 366
 367         a2 = SCons.Action.Action("x\ny\nz")
 368         assert isinstance(a2, SCons.Action.ListAction), f"a2 is {type(a2)}"
 369         assert a2.varlist == (), a2.varlist
 370         assert isinstance(a2.list[0], SCons.Action.CommandAction), a2.list[0]
 371         assert a2.list[0].cmd_list == "x", a2.list[0].cmd_list
 372         assert isinstance(a2.list[1], SCons.Action.CommandAction), a2.list[1]
 373         assert a2.list[1].cmd_list == "y", a2.list[1].cmd_list
 374         assert isinstance(a2.list[2], SCons.Action.CommandAction), a2.list[2]
 375         assert a2.list[2].cmd_list == "z", a2.list[2].cmd_list
 376
 377         def foo() -> None:
 378             pass
 379
 380         a3 = SCons.Action.Action(["x", foo, "z"])
 381         assert isinstance(a3, SCons.Action.ListAction), f"a3 is {type(a3)}"
 382         assert a3.varlist == (), a3.varlist
 383         assert isinstance(a3.list[0], SCons.Action.CommandAction), a3.list[0]
 384         assert a3.list[0].cmd_list == "x", a3.list[0].cmd_list
 385         assert isinstance(a3.list[1], SCons.Action.FunctionAction), a3.list[1]
 386         assert a3.list[1].execfunction == foo, a3.list[1].execfunction
 387         assert isinstance(a3.list[2], SCons.Action.CommandAction), a3.list[2]
 388         assert a3.list[2].cmd_list == "z", a3.list[2].cmd_list
 389
 390         a4 = SCons.Action.Action(["x", "y"], strfunction=foo)
 391         assert isinstance(a4, SCons.Action.ListAction), f"a4 is {type(a4)}"
 392         assert a4.varlist == (), a4.varlist
 393         assert isinstance(a4.list[0], SCons.Action.CommandAction), a4.list[0]
 394         assert a4.list[0].cmd_list == "x", a4.list[0].cmd_list
 395         assert a4.list[0].strfunction == foo, a4.list[0].strfunction
 396         assert isinstance(a4.list[1], SCons.Action.CommandAction), a4.list[1]
 397         assert a4.list[1].cmd_list == "y", a4.list[1].cmd_list
 398         assert a4.list[1].strfunction == foo, a4.list[1].strfunction
 399
 400         a5 = SCons.Action.Action("x\ny", strfunction=foo)
 401         assert isinstance(a5, SCons.Action.ListAction), f"a5 is {type(a5)}"
 402         assert a5.varlist == (), a5.varlist
 403         assert isinstance(a5.list[0], SCons.Action.CommandAction), a5.list[0]
 404         assert a5.list[0].cmd_list == "x", a5.list[0].cmd_list
 405         assert a5.list[0].strfunction == foo, a5.list[0].strfunction
 406         assert isinstance(a5.list[1], SCons.Action.CommandAction), a5.list[1]
 407         assert a5.list[1].cmd_list == "y", a5.list[1].cmd_list
 408         assert a5.list[1].strfunction == foo, a5.list[1].strfunction
 409
 410         a6 = SCons.Action.Action(["action with space"])
 411         assert isinstance(a6, SCons.Action.CommandAction), f"a6 is {type(a6)}"
 412
 413     def test_CommandGeneratorAction(self) -> None:
 414         """Test the Action factory's creation of CommandGeneratorAction objects."""
 415
 416         def foo() -> None: pass
 417
 418         def gen_action(a, foo=foo) -> None:
 419             assert isinstance(a, SCons.Action.CommandGeneratorAction), a
 420             assert a.generator is foo, a.generator
 421
 422         test_positional_args(gen_action, foo, generator=1)
 423
 424     def test_LazyCmdGeneratorAction(self) -> None:
 425         """Test the Action factory's creation of lazy CommandGeneratorAction objects."""
 426
 427         def lazy_action(a) -> None:
 428             assert isinstance(a, SCons.Action.LazyAction), a
 429             assert a.var == "FOO", a.var
 430             assert a.cmd_list == "${FOO}", a.cmd_list
 431
 432         test_positional_args(lazy_action, "$FOO")
 433         test_positional_args(lazy_action, "${FOO}")
 434
 435     def test_no_action(self) -> None:
 436         """Test when the Action() factory can't create an action object."""
 437
 438         try:
 439             a5 = SCons.Action.Action(1)
 440         except TypeError:
 441             pass
 442         else:
 443             assert 0, "Should have thrown a TypeError creating Action from an int."
 444
 445     def test_reentrance(self) -> None:
 446         """Test the Action factory when the action is already an Action object."""
 447
 448         a1 = SCons.Action.Action("foo")
 449         a2 = SCons.Action.Action(a1)
 450         assert a2 is a1, a2
 451
 452
 453 class _ActionActionTestCase(unittest.TestCase):
 454
 455     def test__init__(self) -> None:
 456         """Test creation of _ActionAction objects."""
 457
 458         def func1() -> None:
 459             pass
 460
 461         def func2() -> None:
 462             pass
 463
 464         def func3() -> None:
 465             pass
 466
 467         a = SCons.Action._ActionAction()
 468         assert not hasattr(a, 'strfunction')
 469         assert a.cmdstr is _null, a.cmdstr
 470         assert a.varlist == (), a.varlist
 471         assert a.presub is _null, a.presub
 472         assert a.chdir is None, a.chdir
 473         assert a.exitstatfunc is SCons.Action.default_exitstatfunc, a.exitstatfunc
 474
 475         assert SCons.Action._ActionAction(kwarg=1)
 476         assert not hasattr(a, 'kwarg')
 477         assert not hasattr(a, 'strfunction')
 478         assert a.cmdstr is _null, a.cmdstr
 479         assert a.varlist == (), a.varlist
 480         assert a.presub is _null, a.presub
 481         assert a.chdir is None, a.chdir
 482         assert a.exitstatfunc is SCons.Action.default_exitstatfunc, a.exitstatfunc
 483
 484         a = SCons.Action._ActionAction(strfunction=func1)
 485         assert a.strfunction is func1, a.strfunction
 486
 487         a = SCons.Action._ActionAction(strfunction=None)
 488         assert not hasattr(a, 'strfunction')
 489         assert a.cmdstr is None, a.cmdstr
 490
 491         a = SCons.Action._ActionAction(cmdstr='cmdstr')
 492         assert not hasattr(a, 'strfunction')
 493         assert a.cmdstr == 'cmdstr', a.cmdstr
 494
 495         a = SCons.Action._ActionAction(cmdstr=None)
 496         assert not hasattr(a, 'strfunction')
 497         assert a.cmdstr is None, a.cmdstr
 498
 499         t = ('a', 'b', 'c')
 500         a = SCons.Action._ActionAction(varlist=t)
 501         assert a.varlist == t, a.varlist
 502
 503         a = SCons.Action._ActionAction(presub=func1)
 504         assert a.presub is func1, a.presub
 505
 506         a = SCons.Action._ActionAction(chdir=1)
 507         assert a.chdir == 1, a.chdir
 508
 509         a = SCons.Action._ActionAction(exitstatfunc=func1)
 510         assert a.exitstatfunc is func1, a.exitstatfunc
 511
 512         a = SCons.Action._ActionAction(
 513             # alphabetical order ...
 514             chdir='x',
 515             cmdstr='cmdstr',
 516             exitstatfunc=func3,
 517             presub=func2,
 518             strfunction=func1,
 519             varlist=t,
 520         )
 521         assert a.chdir == 'x', a.chdir
 522         assert a.cmdstr == 'cmdstr', a.cmdstr
 523         assert a.exitstatfunc is func3, a.exitstatfunc
 524         assert a.presub is func2, a.presub
 525         assert a.strfunction is func1, a.strfunction
 526         assert a.varlist is t, a.varlist
 527
 528     def test_dup_keywords(self):
 529         """Test handling of both cmdstr and strfunction arguments."""
 530
 531         def func() -> None:
 532             pass
 533
 534         try:
 535             a = SCons.Action.Action('foo', cmdstr='string', strfunction=func)
 536         except SCons.Errors.UserError as e:
 537             s = str(e)
 538             m = 'Cannot have both strfunction and cmdstr args to Action()'
 539             assert s.find(m) != -1, 'Unexpected string:  %s' % s
 540         else:
 541             raise Exception("did not catch expected UserError")
 542
 543     def test___cmp__(self) -> None:
 544         """Test Action comparison."""
 545
 546         a1 = SCons.Action.Action("x")
 547         a2 = SCons.Action.Action("x")
 548         assert a1 == a2
 549         a3 = SCons.Action.Action("y")
 550         assert a1 != a3
 551         assert a2 != a3
 552
 553     def test_print_cmd_lines(self) -> None:
 554         """Test the print_cmd_lines() method."""
 555
 556         save_stdout = sys.stdout
 557
 558         try:
 559             def execfunc(target, source, env) -> None:
 560                 pass
 561
 562             a = SCons.Action.Action(execfunc)
 563
 564             sio = io.StringIO()
 565             sys.stdout = sio
 566             a.print_cmd_line("foo bar", None, None, None)
 567             s = sio.getvalue()
 568             assert s == "foo bar\n", s
 569
 570         finally:
 571             sys.stdout = save_stdout
 572
 573     def test___call__(self) -> None:
 574         """Test calling an Action."""
 575
 576         save_stdout = sys.stdout
 577
 578         save_print_actions = SCons.Action.print_actions
 579         save_print_actions_presub = SCons.Action.print_actions_presub
 580         save_execute_actions = SCons.Action.execute_actions
 581         # SCons.Action.print_actions = 0
 582
 583         test = TestCmd.TestCmd(workdir='')
 584         test.subdir('sub', 'xyz')
 585         os.chdir(test.workpath())
 586
 587         try:
 588             env = Environment()
 589
 590             def execfunc(target, source, env) -> int:
 591                 assert isinstance(target, list), type(target)
 592                 assert isinstance(source, list), type(source)
 593                 return 7
 594
 595             a = SCons.Action.Action(execfunc)
 596
 597             def firstfunc(target, source, env) -> int:
 598                 assert isinstance(target, list), type(target)
 599                 assert isinstance(source, list), type(source)
 600                 return 0
 601
 602             def lastfunc(target, source, env) -> int:
 603                 assert isinstance(target, list), type(target)
 604                 assert isinstance(source, list), type(source)
 605                 return 9
 606
 607             b = SCons.Action.Action([firstfunc, execfunc, lastfunc])
 608
 609             sio = io.StringIO()
 610             sys.stdout = sio
 611             result = a("out", "in", env)
 612             assert result.status == 7, result
 613             s = sio.getvalue()
 614             assert s == "execfunc(['out'], ['in'])\n", s
 615
 616             a.chdir = 'xyz'
 617             expect = "os.chdir(%s)\nexecfunc(['out'], ['in'])\nos.chdir(%s)\n"
 618
 619             sio = io.StringIO()
 620             sys.stdout = sio
 621             result = a("out", "in", env)
 622             assert result.status == 7, result.status
 623             s = sio.getvalue()
 624             assert s == expect % (repr('xyz'), repr(test.workpath())), s
 625
 626             sio = io.StringIO()
 627             sys.stdout = sio
 628             result = a("out", "in", env, chdir='sub')
 629             assert result.status == 7, result.status
 630             s = sio.getvalue()
 631             assert s == expect % (repr('sub'), repr(test.workpath())), s
 632
 633             a.chdir = None
 634
 635             sio = io.StringIO()
 636             sys.stdout = sio
 637             result = b("out", "in", env)
 638             assert result.status == 7, result.status
 639             s = sio.getvalue()
 640             assert s == "firstfunc(['out'], ['in'])\nexecfunc(['out'], ['in'])\n", s
 641
 642             SCons.Action.execute_actions = 0
 643
 644             sio = io.StringIO()
 645             sys.stdout = sio
 646             result = a("out", "in", env)
 647             assert result == 0, result
 648             s = sio.getvalue()
 649             assert s == "execfunc(['out'], ['in'])\n", s
 650
 651             sio = io.StringIO()
 652             sys.stdout = sio
 653             result = b("out", "in", env)
 654             assert result == 0, result
 655             s = sio.getvalue()
 656             assert s == "firstfunc(['out'], ['in'])\nexecfunc(['out'], ['in'])\nlastfunc(['out'], ['in'])\n", s
 657
 658             SCons.Action.print_actions_presub = 1
 659             SCons.Action.execute_actions = 1
 660
 661             sio = io.StringIO()
 662             sys.stdout = sio
 663             result = a("out", "in", env)
 664             assert result.status == 7, result.status
 665             s = sio.getvalue()
 666             assert s == "Building out with action:\n  execfunc(target, source, env)\nexecfunc(['out'], ['in'])\n", s
 667
 668             sio = io.StringIO()
 669             sys.stdout = sio
 670             result = a("out", "in", env, presub=0)
 671             assert result.status == 7, result.status
 672             s = sio.getvalue()
 673             assert s == "execfunc(['out'], ['in'])\n", s
 674
 675             sio = io.StringIO()
 676             sys.stdout = sio
 677             result = a("out", "in", env, presub=1)
 678             assert result.status == 7, result.status
 679             s = sio.getvalue()
 680             assert s == "Building out with action:\n  execfunc(target, source, env)\nexecfunc(['out'], ['in'])\n", s
 681
 682             sio = io.StringIO()
 683             sys.stdout = sio
 684             result = b(["out"], "in", env, presub=1)
 685             assert result.status == 7, result.status
 686             s = sio.getvalue()
 687             assert s == "Building out with action:\n  firstfunc(target, source, env)\nfirstfunc(['out'], ['in'])\nBuilding out with action:\n  execfunc(target, source, env)\nexecfunc(['out'], ['in'])\n", s
 688
 689             sio = io.StringIO()
 690             sys.stdout = sio
 691             result = b(["out", "list"], "in", env, presub=1)
 692             assert result.status == 7, result.status
 693             s = sio.getvalue()
 694             assert s == "Building out and list with action:\n  firstfunc(target, source, env)\nfirstfunc(['out', 'list'], ['in'])\nBuilding out and list with action:\n  execfunc(target, source, env)\nexecfunc(['out', 'list'], ['in'])\n", s
 695
 696             a2 = SCons.Action.Action(execfunc)
 697
 698             sio = io.StringIO()
 699             sys.stdout = sio
 700             result = a2("out", "in", env)
 701             assert result.status == 7, result.status
 702             s = sio.getvalue()
 703             assert s == "Building out with action:\n  execfunc(target, source, env)\nexecfunc(['out'], ['in'])\n", s
 704
 705             sio = io.StringIO()
 706             sys.stdout = sio
 707             result = a2("out", "in", env, presub=0)
 708             assert result.status == 7, result.status
 709             s = sio.getvalue()
 710             assert s == "execfunc(['out'], ['in'])\n", s
 711
 712             SCons.Action.execute_actions = 0
 713
 714             sio = io.StringIO()
 715             sys.stdout = sio
 716             result = a2("out", "in", env, presub=0)
 717             assert result == 0, result
 718             s = sio.getvalue()
 719             assert s == "execfunc(['out'], ['in'])\n", s
 720
 721             sio = io.StringIO()
 722             sys.stdout = sio
 723             result = a("out", "in", env, presub=0, execute=1, show=0)
 724             assert result.status == 7, result.status
 725             s = sio.getvalue()
 726             assert s == '', s
 727
 728             sys.stdout = save_stdout
 729             exitstatfunc_result = []
 730
 731             def exitstatfunc(stat, result=exitstatfunc_result):
 732                 result.append(stat)
 733                 return stat
 734
 735             result = a("out", "in", env, exitstatfunc=exitstatfunc)
 736             assert result == 0, result
 737             assert exitstatfunc_result == [], exitstatfunc_result
 738
 739             result = a("out", "in", env, execute=1, exitstatfunc=exitstatfunc)
 740             assert result.status == 7, result.status
 741             assert exitstatfunc_result == [7], exitstatfunc_result
 742
 743             SCons.Action.execute_actions = 1
 744
 745             result = []
 746
 747             def my_print_cmd_line(s, target, source, env, result=result) -> None:
 748                 result.append(s)
 749
 750             env['PRINT_CMD_LINE_FUNC'] = my_print_cmd_line
 751             a("output", "input", env)
 752             assert result == ["execfunc(['output'], ['input'])"], result
 753
 754
 755         finally:
 756             sys.stdout = save_stdout
 757             SCons.Action.print_actions = save_print_actions
 758             SCons.Action.print_actions_presub = save_print_actions_presub
 759             SCons.Action.execute_actions = save_execute_actions
 760
 761     def test_presub_lines(self) -> None:
 762         """Test the presub_lines() method."""
 763
 764         env = Environment()
 765         a = SCons.Action.Action("x")
 766         s = a.presub_lines(env)
 767         assert s == ['x'], s
 768
 769         a = SCons.Action.Action(["y", "z"])
 770         s = a.presub_lines(env)
 771         assert s == ['y', 'z'], s
 772
 773         def func() -> None:
 774             pass
 775
 776         a = SCons.Action.Action(func)
 777         s = a.presub_lines(env)
 778         assert s == ["func(target, source, env)"], s
 779
 780         def gen(target, source, env, for_signature):
 781             return 'generat' + env.get('GEN', 'or')
 782
 783         a = SCons.Action.Action(gen, generator=1)
 784         s = a.presub_lines(env)
 785         assert s == ["generator"], s
 786         s = a.presub_lines(Environment(GEN='ed'))
 787         assert s == ["generated"], s
 788
 789         a = SCons.Action.Action("$ACT")
 790         s = a.presub_lines(env)
 791         assert s == [''], s
 792         s = a.presub_lines(Environment(ACT='expanded action'))
 793         assert s == ['expanded action'], s
 794
 795     def test_add(self) -> None:
 796         """Test adding Actions to stuff."""
 797
 798         # Adding actions to other Actions or to stuff that can
 799         # be converted into an Action should produce a ListAction
 800         # containing all the Actions.
 801         def bar():
 802             return None
 803
 804         baz = SCons.Action.Action(bar, generator=1)
 805         act1 = SCons.Action.Action('foo bar')
 806         act2 = SCons.Action.Action(['foo', bar])
 807
 808         sum = act1 + act2
 809         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 810         assert len(sum.list) == 3, len(sum.list)
 811         assert [isinstance(x, SCons.Action.ActionBase) for x in sum.list] == [1, 1, 1]
 812
 813         sum = act1 + act1
 814         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 815         assert len(sum.list) == 2, len(sum.list)
 816
 817         sum = act2 + act2
 818         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 819         assert len(sum.list) == 4, len(sum.list)
 820
 821         # Should also be able to add command generators to each other
 822         # or to actions
 823         sum = baz + baz
 824         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 825         assert len(sum.list) == 2, len(sum.list)
 826
 827         sum = baz + act1
 828         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 829         assert len(sum.list) == 2, len(sum.list)
 830
 831         sum = act2 + baz
 832         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 833         assert len(sum.list) == 3, len(sum.list)
 834
 835         # Also should be able to add Actions to anything that can
 836         # be converted into an action.
 837         sum = act1 + bar
 838         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 839         assert len(sum.list) == 2, len(sum.list)
 840         assert isinstance(sum.list[1], SCons.Action.FunctionAction)
 841
 842         sum = 'foo bar' + act2
 843         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 844         assert len(sum.list) == 3, len(sum.list)
 845         assert isinstance(sum.list[0], SCons.Action.CommandAction)
 846
 847         sum = ['foo', 'bar'] + act1
 848         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 849         assert len(sum.list) == 3, sum.list
 850         assert isinstance(sum.list[0], SCons.Action.CommandAction)
 851         assert isinstance(sum.list[1], SCons.Action.CommandAction)
 852
 853         sum = act2 + [baz, bar]
 854         assert isinstance(sum, SCons.Action.ListAction), str(sum)
 855         assert len(sum.list) == 4, len(sum.list)
 856         assert isinstance(sum.list[2], SCons.Action.CommandGeneratorAction)
 857         assert isinstance(sum.list[3], SCons.Action.FunctionAction)
 858
 859         # OK to add None on either side (should be ignored)
 860         sum = act1 + None
 861         assert sum == act1
 862
 863         sum = None + act1
 864         assert sum == act1
 865
 866         try:
 867             sum = act2 + 1
 868         except TypeError:
 869             pass
 870         else:
 871             assert 0, "Should have thrown a TypeError adding to an int."
 872
 873         try:
 874             sum = 1 + act2
 875         except TypeError:
 876             pass
 877         else:
 878             assert 0, "Should have thrown a TypeError adding to an int."
 879
 880
 881 class CommandActionTestCase(unittest.TestCase):
 882
 883     def test___init__(self) -> None:
 884         """Test creation of a command Action."""
 885
 886         a = SCons.Action.CommandAction(["xyzzy"])
 887         assert a.cmd_list == ["xyzzy"], a.cmd_list
 888         assert a.cmdstr is _null, a.cmdstr
 889
 890         a = SCons.Action.CommandAction(["abra"], cmdstr="cadabra")
 891         assert a.cmd_list == ["abra"], a.cmd_list
 892         assert a.cmdstr == "cadabra", a.cmdstr
 893
 894     def test___str__(self) -> None:
 895         """Test fetching the pre-substitution string for command Actions."""
 896
 897         env = Environment()
 898         act = SCons.Action.CommandAction('xyzzy $TARGET $SOURCE')
 899         s = str(act)
 900         assert s == 'xyzzy $TARGET $SOURCE', s
 901
 902         act = SCons.Action.CommandAction(['xyzzy',
 903                                           '$TARGET', '$SOURCE',
 904                                           '$TARGETS', '$SOURCES'])
 905         s = str(act)
 906         assert s == "xyzzy $TARGET $SOURCE $TARGETS $SOURCES", s
 907
 908     def test_genstring(self) -> None:
 909         """Test the genstring() method for command Actions."""
 910
 911         env = Environment()
 912         t1 = DummyNode('t1')
 913         t2 = DummyNode('t2')
 914         s1 = DummyNode('s1')
 915         s2 = DummyNode('s2')
 916         act = SCons.Action.CommandAction('xyzzy $TARGET $SOURCE')
 917         expect = 'xyzzy $TARGET $SOURCE'
 918         s = act.genstring([], [], env)
 919         assert s == expect, s
 920         s = act.genstring([t1], [s1], env)
 921         assert s == expect, s
 922         s = act.genstring([t1, t2], [s1, s2], env)
 923         assert s == expect, s
 924
 925         act = SCons.Action.CommandAction('xyzzy $TARGETS $SOURCES')
 926         expect = 'xyzzy $TARGETS $SOURCES'
 927         s = act.genstring([], [], env)
 928         assert s == expect, s
 929         s = act.genstring([t1], [s1], env)
 930         assert s == expect, s
 931         s = act.genstring([t1, t2], [s1, s2], env)
 932         assert s == expect, s
 933
 934         act = SCons.Action.CommandAction(['xyzzy',
 935                                           '$TARGET', '$SOURCE',
 936                                           '$TARGETS', '$SOURCES'])
 937         expect = "xyzzy $TARGET $SOURCE $TARGETS $SOURCES"
 938         s = act.genstring([], [], env)
 939         assert s == expect, s
 940         s = act.genstring([t1], [s1], env)
 941         assert s == expect, s
 942         s = act.genstring([t1, t2], [s1, s2], env)
 943         assert s == expect, s
 944
 945     def test_strfunction(self) -> None:
 946         """Test fetching the string representation of command Actions."""
 947
 948         env = Environment()
 949         t1 = DummyNode('t1')
 950         t2 = DummyNode('t2')
 951         s1 = DummyNode('s1')
 952         s2 = DummyNode('s2')
 953         act = SCons.Action.CommandAction('xyzzy $TARGET $SOURCE')
 954         s = act.strfunction([], [], env)
 955         assert s == 'xyzzy', s
 956         s = act.strfunction([t1], [s1], env)
 957         assert s == 'xyzzy t1 s1', s
 958         s = act.strfunction([t1, t2], [s1, s2], env)
 959         assert s == 'xyzzy t1 s1', s
 960
 961         act = SCons.Action.CommandAction('xyzzy $TARGET $SOURCE',
 962                                          cmdstr='cmdstr - $SOURCE - $TARGET -')
 963         s = act.strfunction([], [], env)
 964         assert s == 'cmdstr -  -  -', s
 965         s = act.strfunction([t1], [s1], env)
 966         assert s == 'cmdstr - s1 - t1 -', s
 967         s = act.strfunction([t1, t2], [s1, s2], env)
 968         assert s == 'cmdstr - s1 - t1 -', s
 969
 970         act = SCons.Action.CommandAction('xyzzy $TARGETS $SOURCES')
 971         s = act.strfunction([], [], env)
 972         assert s == 'xyzzy', s
 973         s = act.strfunction([t1], [s1], env)
 974         assert s == 'xyzzy t1 s1', s
 975         s = act.strfunction([t1, t2], [s1, s2], env)
 976         assert s == 'xyzzy t1 t2 s1 s2', s
 977
 978         act = SCons.Action.CommandAction('xyzzy $TARGETS $SOURCES',
 979                                          cmdstr='cmdstr = $SOURCES = $TARGETS =')
 980         s = act.strfunction([], [], env)
 981         assert s == 'cmdstr =  =  =', s
 982         s = act.strfunction([t1], [s1], env)
 983         assert s == 'cmdstr = s1 = t1 =', s
 984         s = act.strfunction([t1, t2], [s1, s2], env)
 985         assert s == 'cmdstr = s1 s2 = t1 t2 =', s
 986
 987         act = SCons.Action.CommandAction(['xyzzy',
 988                                           '$TARGET', '$SOURCE',
 989                                           '$TARGETS', '$SOURCES'])
 990         s = act.strfunction([], [], env)
 991         assert s == 'xyzzy', s
 992         s = act.strfunction([t1], [s1], env)
 993         assert s == 'xyzzy t1 s1 t1 s1', s
 994         s = act.strfunction([t1, t2], [s1, s2], env)
 995         assert s == 'xyzzy t1 s1 t1 t2 s1 s2', s
 996
 997         act = SCons.Action.CommandAction('xyzzy $TARGETS $SOURCES',
 998                                          cmdstr='cmdstr\t$TARGETS\n$SOURCES   ')
 999
1000         s = act.strfunction([], [], env)
1001         assert s == 'cmdstr\t\n   ', s
1002         s = act.strfunction([t1], [s1], env)
1003         assert s == 'cmdstr\tt1\ns1   ', s
1004         s = act.strfunction([t1, t2], [s1, s2], env)
1005         assert s == 'cmdstr\tt1 t2\ns1 s2   ', s
1006
1007         def sf(target, source, env) -> str:
1008             return "sf was called"
1009
1010         act = SCons.Action.CommandAction('foo', strfunction=sf)
1011         s = act.strfunction([], [], env)
1012         assert s == "sf was called", s
1013
1014         class actclass1:
1015             def __init__(self, targets, sources, env) -> None:
1016                 pass
1017
1018             def __call__(self) -> int:
1019                 return 1
1020
1021         class actclass2:
1022             def __init__(self, targets, sources, env) -> None:
1023                 self.strfunction = 5
1024
1025             def __call__(self) -> int:
1026                 return 2
1027
1028         class actclass3:
1029             def __init__(self, targets, sources, env) -> None:
1030                 pass
1031
1032             def __call__(self) -> int:
1033                 return 3
1034
1035             def strfunction(self, targets, sources, env) -> str:
1036                 return 'actclass3 on %s to get %s' % (str(sources[0]),
1037                                                       str(targets[0]))
1038
1039         class actclass4:
1040             def __init__(self, targets, sources, env) -> None:
1041                 pass
1042
1043             def __call__(self) -> int:
1044                 return 4
1045
1046             strfunction = None
1047
1048         act1 = SCons.Action.Action(actclass1([t1], [s1], env))
1049         s = act1.strfunction([t1], [s1], env)
1050         assert s == 'actclass1(["t1"], ["s1"])', s
1051
1052         act2 = SCons.Action.Action(actclass2([t1], [s1], env))
1053         s = act2.strfunction([t1], [s1], env)
1054         assert s == 'actclass2(["t1"], ["s1"])', s
1055
1056         act3 = SCons.Action.Action(actclass3([t1], [s1], env))
1057         s = act3.strfunction([t1], [s1], env)
1058         assert s == 'actclass3 on s1 to get t1', s
1059
1060         act4 = SCons.Action.Action(actclass4([t1], [s1], env))
1061         s = act4.strfunction([t1], [s1], env)
1062         assert s is None, s
1063
1064         act = SCons.Action.CommandAction("@foo bar")
1065         s = act.strfunction([], [], env)
1066         assert s == "", s
1067
1068         act = SCons.Action.CommandAction("@-foo bar")
1069         s = act.strfunction([], [], env)
1070         assert s == "", s
1071
1072         act = SCons.Action.CommandAction("-@foo bar")
1073         s = act.strfunction([], [], env)
1074         assert s == "", s
1075
1076         act = SCons.Action.CommandAction("-foo bar")
1077         s = act.strfunction([], [], env)
1078         assert s == "foo bar", s
1079
1080         act = SCons.Action.CommandAction("@ foo bar")
1081         s = act.strfunction([], [], env)
1082         assert s == "", s
1083
1084         act = SCons.Action.CommandAction("@- foo bar")
1085         s = act.strfunction([], [], env)
1086         assert s == "", s
1087
1088         act = SCons.Action.CommandAction("-@ foo bar")
1089         s = act.strfunction([], [], env)
1090         assert s == "", s
1091
1092         act = SCons.Action.CommandAction("- foo bar")
1093         s = act.strfunction([], [], env)
1094         assert s == "foo bar", s
1095
1096     def test_execute(self) -> None:
1097         """Test execution of command Actions."""
1098
1099         try:
1100             env = self.env
1101         except AttributeError:
1102             env = Environment()
1103
1104         cmd1 = r'%s %s %s xyzzy' % (_python_, act_py, outfile)
1105
1106         act = SCons.Action.CommandAction(cmd1)
1107         r = act([], [], env.Clone())
1108         assert r == 0
1109         c = test.read(outfile, 'r')
1110         assert c == "act.py: 'xyzzy'\n", c
1111
1112         cmd2 = r'%s %s %s $TARGET' % (_python_, act_py, outfile)
1113
1114         act = SCons.Action.CommandAction(cmd2)
1115         r = act(DummyNode('foo'), [], env.Clone())
1116         assert r == 0
1117         c = test.read(outfile, 'r')
1118         assert c == "act.py: 'foo'\n", c
1119
1120         cmd3 = r'%s %s %s ${TARGETS}' % (_python_, act_py, outfile)
1121
1122         act = SCons.Action.CommandAction(cmd3)
1123         r = act(list(map(DummyNode, ['aaa', 'bbb'])), [], env.Clone())
1124         assert r == 0
1125         c = test.read(outfile, 'r')
1126         assert c == "act.py: 'aaa' 'bbb'\n", c
1127
1128         cmd4 = r'%s %s %s $SOURCES' % (_python_, act_py, outfile)
1129
1130         act = SCons.Action.CommandAction(cmd4)
1131         r = act([], [DummyNode('one'), DummyNode('two')], env.Clone())
1132         assert r == 0
1133         c = test.read(outfile, 'r')
1134         assert c == "act.py: 'one' 'two'\n", c
1135
1136         cmd4 = r'%s %s %s ${SOURCES[:2]}' % (_python_, act_py, outfile)
1137
1138         act = SCons.Action.CommandAction(cmd4)
1139         sources = [DummyNode('three'), DummyNode('four'), DummyNode('five')]
1140         env2 = env.Clone()
1141         r = act([], source=sources, env=env2)
1142         assert r == 0
1143         c = test.read(outfile, 'r')
1144         assert c == "act.py: 'three' 'four'\n", c
1145
1146         cmd5 = r'%s %s %s $TARGET XYZZY' % (_python_, act_py, outfile)
1147
1148         act = SCons.Action.CommandAction(cmd5)
1149         env5 = Environment()
1150         if 'ENV' in scons_env:
1151             env5['ENV'] = scons_env['ENV']
1152             PATH = scons_env['ENV'].get('PATH', '')
1153         else:
1154             env5['ENV'] = {}
1155             PATH = ''
1156
1157         env5['ENV']['XYZZY'] = 'xyzzy'
1158         r = act(target=DummyNode('out5'), source=[], env=env5)
1159
1160         act = SCons.Action.CommandAction(cmd5)
1161         r = act(target=DummyNode('out5'),
1162                 source=[],
1163                 env=env.Clone(ENV={'XYZZY': 'xyzzy5',
1164                                    'PATH': PATH}))
1165         assert r == 0
1166         c = test.read(outfile, 'r')
1167         assert c == "act.py: 'out5' 'XYZZY'\nact.py: 'xyzzy5'\n", c
1168
1169         class Obj:
1170             def __init__(self, str) -> None:
1171                 self._str = str
1172
1173             def __str__(self) -> str:
1174                 return self._str
1175
1176             def rfile(self):
1177                 return self
1178
1179             def get_subst_proxy(self):
1180                 return self
1181
1182         cmd6 = r'%s %s %s ${TARGETS[1]} $TARGET ${SOURCES[:2]}' % (_python_, act_py, outfile)
1183
1184         act = SCons.Action.CommandAction(cmd6)
1185         r = act(target=[Obj('111'), Obj('222')],
1186                 source=[Obj('333'), Obj('444'), Obj('555')],
1187                 env=env.Clone())
1188         assert r == 0
1189         c = test.read(outfile, 'r')
1190         assert c == "act.py: '222' '111' '333' '444'\n", c
1191
1192         if os.name == 'nt':
1193             # NT treats execs of directories and non-executable files
1194             # as "file not found" errors
1195             expect_nonexistent = 1
1196             expect_nonexecutable_file = 1
1197             expect_nonexecutable_dir = 1
1198         elif sys.platform == 'cygwin':
1199             expect_nonexistent = 127
1200             # Newer cygwin seems to return 126 for following
1201             expect_nonexecutable_file = 126
1202             expect_nonexecutable_dir = 127
1203         else:
1204             expect_nonexistent = 127
1205             expect_nonexecutable_file = 126
1206             expect_nonexecutable_dir = 126
1207
1208         # Test that a nonexistent command returns 127
1209         act = SCons.Action.CommandAction(python + "_no_such_command_")
1210         r = act([], [], env.Clone(out=outfile))
1211         assert r.status == expect_nonexistent, r.status
1212
1213         # Test that trying to execute a directory returns 126
1214         dir, tail = os.path.split(python)
1215         act = SCons.Action.CommandAction(dir)
1216         r = act([], [], env.Clone(out=outfile))
1217         assert r.status == expect_nonexecutable_file, r.status
1218
1219         # Test that trying to execute a non-executable file returns 126
1220         act = SCons.Action.CommandAction(outfile)
1221         r = act([], [], env.Clone(out=outfile))
1222         assert r.status == expect_nonexecutable_dir, r.status
1223
1224         act = SCons.Action.CommandAction('%s %s 1' % (_python_, exit_py))
1225         r = act([], [], env)
1226         assert r.status == 1, r.status
1227
1228         act = SCons.Action.CommandAction('@%s %s 1' % (_python_, exit_py))
1229         r = act([], [], env)
1230         assert r.status == 1, r.status
1231
1232         act = SCons.Action.CommandAction('@-%s %s 1' % (_python_, exit_py))
1233         r = act([], [], env)
1234         assert r == 0, r
1235
1236         act = SCons.Action.CommandAction('-%s %s 1' % (_python_, exit_py))
1237         r = act([], [], env)
1238         assert r == 0, r
1239
1240         act = SCons.Action.CommandAction('@ %s %s 1' % (_python_, exit_py))
1241         r = act([], [], env)
1242         assert r.status == 1, r.status
1243
1244         act = SCons.Action.CommandAction('@- %s %s 1' % (_python_, exit_py))
1245         r = act([], [], env)
1246         assert r == 0, r
1247
1248         act = SCons.Action.CommandAction('- %s %s 1' % (_python_, exit_py))
1249         r = act([], [], env)
1250         assert r == 0, r
1251
1252     def test_set_handler(self) -> None:
1253         """Test setting the command handler..."""
1254
1255         class Test:
1256             def __init__(self) -> None:
1257                 self.executed = 0
1258
1259         t = Test()
1260
1261         def func(sh, escape, cmd, args, env, test=t) -> int:
1262             test.executed = args
1263             test.shell = sh
1264             return 0
1265
1266         def escape_func(cmd):
1267             return '**' + cmd + '**'
1268
1269         class LiteralStr:
1270             def __init__(self, x) -> None:
1271                 self.data = x
1272
1273             def __str__(self) -> str:
1274                 return self.data
1275
1276             def escape(self, escape_func):
1277                 return escape_func(self.data)
1278
1279             def is_literal(self) -> bool:
1280                 return True
1281
1282         a = SCons.Action.CommandAction(["xyzzy"])
1283         e = Environment(SPAWN=func)
1284         a([], [], e)
1285         assert t.executed == ['xyzzy'], t.executed
1286
1287         a = SCons.Action.CommandAction(["xyzzy"])
1288         e = Environment(SPAWN='$FUNC', FUNC=func)
1289         a([], [], e)
1290         assert t.executed == ['xyzzy'], t.executed
1291
1292         a = SCons.Action.CommandAction(["xyzzy"])
1293         e = Environment(SPAWN=func, SHELL='fake shell')
1294         a([], [], e)
1295         assert t.executed == ['xyzzy'], t.executed
1296         assert t.shell == 'fake shell', t.shell
1297
1298         a = SCons.Action.CommandAction([LiteralStr("xyzzy")])
1299         e = Environment(SPAWN=func, ESCAPE=escape_func)
1300         a([], [], e)
1301         assert t.executed == ['**xyzzy**'], t.executed
1302
1303     def test_get_contents(self) -> None:
1304         """Test fetching the contents of a command Action."""
1305
1306         def CmdGen(target, source, env, for_signature) -> str:
1307             assert for_signature
1308             return "%s %s" % \
1309                    (env["foo"], env["bar"])
1310
1311         # The number 1 is there to make sure all args get converted to strings.
1312         a = SCons.Action.CommandAction(["|", "$(", "$foo", "|", "$(", "$bar",
1313                                         "$)", "stuff", "$)", "|", "$baz", 1])
1314         c = a.get_contents(target=[], source=[],
1315                            env=Environment(foo='FFF', bar='BBB',
1316                                            baz=CmdGen))
1317         assert c == b"| | FFF BBB 1", c
1318
1319         # Make sure that CommandActions use an Environment's
1320         # subst_target_source() method for substitution.
1321         class SpecialEnvironment(Environment):
1322             def subst_target_source(self, strSubst, raw: int=0, target=[], source=[]):
1323                 return 'subst_target_source: ' + strSubst
1324
1325         c = a.get_contents(target=DummyNode('ttt'), source=DummyNode('sss'),
1326                            env=SpecialEnvironment(foo='GGG', bar='CCC',
1327                                                   baz='ZZZ'))
1328         assert c == b'subst_target_source: | $( $foo | $( $bar $) stuff $) | $baz 1', c
1329
1330         # We've discussed using the real target and source names in a
1331         # CommandAction's signature contents.  This would have have the
1332         # advantage of recompiling when a file's name changes (keeping
1333         # debug info current), but it would currently break repository
1334         # logic that will change the file name based on whether the
1335         # files come from a repository or locally.  If we ever move to
1336         # that scheme, then all of the '__t1__' and '__s6__' file names
1337         # in the asserts below would change to 't1' and 's6' and the
1338         # like.
1339         t = list(map(DummyNode, ['t1', 't2', 't3', 't4', 't5', 't6']))
1340         s = list(map(DummyNode, ['s1', 's2', 's3', 's4', 's5', 's6']))
1341         env = Environment()
1342
1343         a = SCons.Action.CommandAction(["$TARGET"])
1344         c = a.get_contents(target=t, source=s, env=env)
1345         assert c == b"t1", c
1346
1347         a = SCons.Action.CommandAction(["$TARGETS"])
1348         c = a.get_contents(target=t, source=s, env=env)
1349         assert c == b"t1 t2 t3 t4 t5 t6", c
1350
1351         a = SCons.Action.CommandAction(["${TARGETS[2]}"])
1352         c = a.get_contents(target=t, source=s, env=env)
1353         assert c == b"t3", c
1354
1355         a = SCons.Action.CommandAction(["${TARGETS[3:5]}"])
1356         c = a.get_contents(target=t, source=s, env=env)
1357         assert c == b"t4 t5", c
1358
1359         a = SCons.Action.CommandAction(["$SOURCE"])
1360         c = a.get_contents(target=t, source=s, env=env)
1361         assert c == b"s1", c
1362
1363         a = SCons.Action.CommandAction(["$SOURCES"])
1364         c = a.get_contents(target=t, source=s, env=env)
1365         assert c == b"s1 s2 s3 s4 s5 s6", c
1366
1367         a = SCons.Action.CommandAction(["${SOURCES[2]}"])
1368         c = a.get_contents(target=t, source=s, env=env)
1369         assert c == b"s3", c
1370
1371         a = SCons.Action.CommandAction(["${SOURCES[3:5]}"])
1372         c = a.get_contents(target=t, source=s, env=env)
1373         assert c == b"s4 s5", c
1374
1375     def test_get_implicit_deps(self) -> None:
1376         """Test getting the implicit dependencies of a command Action."""
1377
1378         class SpecialEnvironment(Environment):
1379             def WhereIs(self, prog):
1380                 return prog
1381
1382             class fs:
1383                 def File(name):
1384                     return name
1385
1386         env = SpecialEnvironment()
1387         a = SCons.Action.CommandAction([_python_, exit_py])
1388         self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [_python_])
1389
1390         for false_like_value in [False, 0, None, "None", "False", "0", "NONE", "FALSE", "off", "OFF", "NO", "no"]:
1391             env = SpecialEnvironment(IMPLICIT_COMMAND_DEPENDENCIES=false_like_value)
1392             a = SCons.Action.CommandAction([_python_, exit_py])
1393             self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [])
1394
1395             env = SpecialEnvironment(IMPLICIT_COMMAND_DEPENDENCIES="$SUBST_VALUE", SUBST_VALUE=false_like_value)
1396             a = SCons.Action.CommandAction([_python_, exit_py])
1397             self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [])
1398
1399         for true_like_value in [True, 1, "True", "TRUE", "1"]:
1400             env = SpecialEnvironment(IMPLICIT_COMMAND_DEPENDENCIES=true_like_value)
1401             a = SCons.Action.CommandAction([_python_, exit_py])
1402             self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [_python_])
1403
1404             env = SpecialEnvironment(IMPLICIT_COMMAND_DEPENDENCIES="$SUBST_VALUE", SUBST_VALUE=true_like_value)
1405             a = SCons.Action.CommandAction([_python_, exit_py])
1406             self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [_python_])
1407
1408         for all_like_Value in ["all", "ALL", 2, "2"]:
1409             env = SpecialEnvironment(IMPLICIT_COMMAND_DEPENDENCIES=all_like_Value)
1410             a = SCons.Action.CommandAction([_python_, exit_py])
1411             self.assertEqual(a.get_implicit_deps(target=[], source=[], env=env), [_python_, exit_py])
1412
1413
1414 class CommandGeneratorActionTestCase(unittest.TestCase):
1415
1416     def factory(self, act, **kw):
1417         """Pass any keywords as a dict"""
1418
1419         return SCons.Action.CommandGeneratorAction(act, kw)
1420
1421     def test___init__(self) -> None:
1422         """Test creation of a command generator Action."""
1423
1424         def f(target, source, env) -> None:
1425             pass
1426
1427         a = self.factory(f)
1428         assert a.generator == f
1429
1430     def test___str__(self) -> None:
1431         """Test the pre-substitution strings for command generator Actions."""
1432
1433         def f(target, source, env, for_signature, self=self) -> str:
1434             # See if "env" is really a construction environment (or
1435             # looks like one) by accessing the FindIxes attribute.
1436             # (The Tool/mingw.py module has a generator that uses this,
1437             # and the __str__() method used to cause problems by passing
1438             # us a regular dictionary as a fallback.)
1439
1440             env.FindIxes
1441             return "FOO"
1442
1443         a = self.factory(f)
1444         s = str(a)
1445         assert s == 'FOO', s
1446
1447     def test_genstring(self) -> None:
1448         """Test the command generator Action genstring() method."""
1449
1450         def f(target, source, env, for_signature, self=self) -> str:
1451             dummy = env['dummy']
1452             self.dummy = dummy
1453             return "$FOO $TARGET $SOURCE $TARGETS $SOURCES"
1454
1455         a = self.factory(f)
1456         self.dummy = 0
1457         s = a.genstring([], [], env=Environment(FOO='xyzzy', dummy=1))
1458         assert self.dummy == 1, self.dummy
1459         assert s == "$FOO $TARGET $SOURCE $TARGETS $SOURCES", s
1460
1461     def test_execute(self) -> None:
1462         """Test executing a command generator Action."""
1463
1464         def f(target, source, env, for_signature, self=self) -> str:
1465             dummy = env['dummy']
1466             self.dummy = dummy
1467             s = env.subst("$FOO")
1468             assert s == 'foo baz\nbar ack', s
1469             return "$FOO"
1470
1471         def func_action(target, source, env, self=self) -> None:
1472             dummy = env['dummy']
1473             s = env.subst('$foo')
1474             assert s == 'bar', s
1475             self.dummy = dummy
1476
1477         def f2(target, source, env, for_signature, f=func_action):
1478             return f
1479
1480         def ch(sh, escape, cmd, args, env, self=self) -> None:
1481             self.cmd.append(cmd)
1482             self.args.append(args)
1483
1484         a = self.factory(f)
1485         self.dummy = 0
1486         self.cmd = []
1487         self.args = []
1488         a([], [], env=Environment(FOO='foo baz\nbar ack',
1489                                   dummy=1,
1490                                   SPAWN=ch))
1491         assert self.dummy == 1, self.dummy
1492         assert self.cmd == ['foo', 'bar'], self.cmd
1493         assert self.args == [['foo', 'baz'], ['bar', 'ack']], self.args
1494
1495         b = self.factory(f2)
1496         self.dummy = 0
1497         b(target=[], source=[], env=Environment(foo='bar',
1498                                                 dummy=2))
1499         assert self.dummy == 2, self.dummy
1500         del self.dummy
1501
1502         class DummyFile:
1503             def __init__(self, t) -> None:
1504                 self.t = t
1505
1506             def rfile(self):
1507                 self.t.rfile_called = 1
1508                 return self
1509
1510             def get_subst_proxy(self):
1511                 return self
1512
1513         def f3(target, source, env, for_signature) -> str:
1514             return ''
1515
1516         c = self.factory(f3)
1517         c(target=[], source=DummyFile(self), env=Environment())
1518         assert self.rfile_called
1519
1520     def test_get_contents(self) -> None:
1521         """Test fetching the contents of a command generator Action."""
1522
1523         def f(target, source, env, for_signature):
1524             foo = env['foo']
1525             bar = env['bar']
1526             assert for_signature, for_signature
1527             return [["guux", foo, "$(", "$ignore", "$)", bar,
1528                      '${test("$( foo $bar $)")}']]
1529
1530         def test(mystr) -> str:
1531             assert mystr == "$( foo $bar $)", mystr
1532             return "test"
1533
1534         env = Environment(foo='FFF', bar='BBB',
1535                           ignore='foo', test=test)
1536         a = self.factory(f)
1537         c = a.get_contents(target=[], source=[], env=env)
1538         assert c == b"guux FFF BBB test", c
1539
1540     def test_get_contents_of_function_action(self) -> None:
1541         """Test contents of a CommandGeneratorAction-generated FunctionAction."""
1542
1543         def LocalFunc() -> None:
1544             pass
1545
1546         # Since the python bytecode has per version differences, we need different expected results per version
1547         func_matches = {
1548             (3, 7): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1549             (3, 8): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1550             (3, 9): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1551             (3, 10): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1552             (3, 11): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00d\x00S\x00),(),()'),
1553             (3, 12): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00y\x00),(),()'),
1554             (3, 13): bytearray(b'0, 0, 0, 0,(),(),(\x95\x00g\x00),(),()'),
1555         }
1556
1557         meth_matches = [
1558             b"1, 1, 0, 0,(),(),(d\000\000S),(),()",
1559             b"1, 1, 0, 0,(),(),(d\x00\x00S),(),()",
1560         ]
1561
1562         def f_global(target, source, env, for_signature):
1563             return SCons.Action.Action(GlobalFunc)
1564
1565         def f_local(target, source, env, for_signature):
1566             return SCons.Action.Action(LocalFunc)
1567
1568         env = Environment(XYZ='foo')
1569
1570         with self.subTest():
1571             a = self.factory(f_global)
1572             c = a.get_contents(target=[], source=[], env=env)
1573             self.assertEqual(c, func_matches[sys.version_info[:2]])
1574
1575         with self.subTest():
1576             a = self.factory(f_local)
1577             c = a.get_contents(target=[], source=[], env=env)
1578             self.assertEqual(c, func_matches[sys.version_info[:2]])
1579
1580         def f_global2(target, source, env, for_signature):
1581             return SCons.Action.Action(GlobalFunc, varlist=['XYZ'])
1582
1583         def f_local2(target, source, env, for_signature):
1584             return SCons.Action.Action(LocalFunc, varlist=['XYZ'])
1585
1586         matches_foo = func_matches[sys.version_info[:2]] + b'foo'
1587
1588         with self.subTest():
1589             a = self.factory(f_global2)
1590             c = a.get_contents(target=[], source=[], env=env)
1591             self.assertIn(c, matches_foo)
1592
1593         with self.subTest():
1594             a = self.factory(f_local2)
1595             c = a.get_contents(target=[], source=[], env=env)
1596             self.assertIn(c, matches_foo)
1597
1598
1599 class FunctionActionTestCase(unittest.TestCase):
1600
1601     def test___init__(self) -> None:
1602         """Test creation of a function Action."""
1603
1604         def func1() -> None:
1605             pass
1606
1607         def func2() -> None:
1608             pass
1609
1610         def func3() -> None:
1611             pass
1612
1613         def func4() -> None:
1614             pass
1615
1616         a = SCons.Action.FunctionAction(func1, {})
1617         assert a.execfunction == func1, a.execfunction
1618         assert isinstance(a.strfunction, types.MethodType), type(a.strfunction)
1619
1620         a = SCons.Action.FunctionAction(func2, {'strfunction': func3})
1621         assert a.execfunction == func2, a.execfunction
1622         assert a.strfunction == func3, a.strfunction
1623
1624     def test___str__(self) -> None:
1625         """Test the __str__() method for function Actions."""
1626
1627         def func1() -> None:
1628             pass
1629
1630         a = SCons.Action.FunctionAction(func1, {})
1631         s = str(a)
1632         assert s == "func1(target, source, env)", s
1633
1634         class class1:
1635             def __call__(self) -> None:
1636                 pass
1637
1638         a = SCons.Action.FunctionAction(class1(), {})
1639         s = str(a)
1640         assert s == "class1(target, source, env)", s
1641
1642     def test_execute(self) -> None:
1643         """Test executing a function Action."""
1644
1645         self.inc = 0
1646
1647         def f(target, source, env) -> int:
1648             s = env['s']
1649             s.inc = s.inc + 1
1650             s.target = target
1651             s.source = source
1652             assert env.subst("$BAR") == 'foo bar', env.subst("$BAR")
1653             return 0
1654
1655         a = SCons.Action.FunctionAction(f, {})
1656         a(target=1, source=2, env=Environment(BAR='foo bar',
1657                                               s=self))
1658         assert self.inc == 1, self.inc
1659         assert self.source == [2], self.source
1660         assert self.target == [1], self.target
1661
1662         global count
1663         count = 0
1664
1665         def function1(target, source, env) -> int:
1666             global count
1667             count = count + 1
1668             for t in target:
1669                 with open(t, 'w') as f:
1670                     f.write("function1\n")
1671             return 1
1672
1673         act = SCons.Action.FunctionAction(function1, {})
1674         r = act(target=[outfile, outfile2], source=[], env=Environment())
1675         assert r.status == 1, r.status
1676
1677         assert count == 1, count
1678         c = test.read(outfile, 'r')
1679         assert c == "function1\n", c
1680         c = test.read(outfile2, 'r')
1681         assert c == "function1\n", c
1682
1683         class class1a:
1684             def __init__(self, target, source, env) -> None:
1685                 with open(env['out'], 'w') as f:
1686                     f.write("class1a\n")
1687
1688         act = SCons.Action.FunctionAction(class1a, {})
1689         r = act([], [], Environment(out=outfile))
1690         assert isinstance(r.status, class1a), r.status
1691         c = test.read(outfile, 'r')
1692         assert c == "class1a\n", c
1693
1694         class class1b:
1695             def __call__(self, target, source, env) -> int:
1696                 with open(env['out'], 'w') as f:
1697                     f.write("class1b\n")
1698                 return 2
1699
1700         act = SCons.Action.FunctionAction(class1b(), {})
1701         r = act([], [], Environment(out=outfile))
1702         assert r.status == 2, r.status
1703         c = test.read(outfile, 'r')
1704         assert c == "class1b\n", c
1705
1706         def build_it(target, source, env, executor: Executor | None = None, self=self) -> int:
1707             self.build_it = 1
1708             return 0
1709
1710         def string_it(target, source, env, executor: Executor | None = None, self=self):
1711             self.string_it = 1
1712             return None
1713
1714         act = SCons.Action.FunctionAction(build_it,
1715                                           {'strfunction': string_it})
1716         r = act([], [], Environment())
1717         assert r == 0, r
1718         assert self.build_it
1719         assert self.string_it
1720
1721     def test_get_contents(self) -> None:
1722         """Test fetching the contents of a function Action."""
1723
1724         def LocalFunc() -> None:
1725             pass
1726
1727         func_matches = {
1728             (3, 7): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1729             (3, 8): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1730             (3, 9): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1731             (3, 10): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1732             (3, 11): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00d\x00S\x00),(),()'),
1733             (3, 12): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00y\x00),(),()'),
1734             (3, 13): bytearray(b'0, 0, 0, 0,(),(),(\x95\x00g\x00),(),()'),
1735
1736         }
1737
1738         meth_matches = {
1739             (3, 7): bytearray(b'1, 1, 0, 0,(),(),(d\x00S\x00),(),()'),
1740             (3, 8): bytearray(b'1, 1, 0, 0,(),(),(d\x00S\x00),(),()'),
1741             (3, 9): bytearray(b'1, 1, 0, 0,(),(),(d\x00S\x00),(),()'),
1742             (3, 10): bytearray(b'1, 1, 0, 0,(),(),(d\x00S\x00),(),()'),
1743             (3, 11): bytearray(b'1, 1, 0, 0,(),(),(\x97\x00d\x00S\x00),(),()'),
1744             (3, 12): bytearray(b'1, 1, 0, 0,(),(),(\x97\x00y\x00),(),()'),
1745             (3, 13): bytearray(b'1, 1, 0, 0,(),(),(\x95\x00g\x00),(),()'),
1746         }
1747
1748         def factory(act, **kw):
1749             return SCons.Action.FunctionAction(act, kw)
1750
1751         with self.subTest():
1752             a = factory(GlobalFunc)
1753             c = a.get_contents(target=[], source=[], env=Environment())
1754             self.assertEqual(c, func_matches[sys.version_info[:2]])
1755
1756         with self.subTest():
1757             a = factory(LocalFunc)
1758             c = a.get_contents(target=[], source=[], env=Environment())
1759             self.assertEqual(c, func_matches[sys.version_info[:2]])
1760
1761         matches_foo = func_matches[sys.version_info[:2]] + b'foo'
1762
1763         with self.subTest():
1764             a = factory(GlobalFunc, varlist=['XYZ'])
1765             c = a.get_contents(target=[], source=[], env=Environment())
1766             self.assertEqual(c, func_matches[sys.version_info[:2]])
1767
1768         with self.subTest():
1769             c = a.get_contents(target=[], source=[], env=Environment(XYZ='foo'))
1770             self.assertEqual(c, matches_foo)
1771
1772         ##TODO: is this set of tests still needed?
1773         # Make sure a bare string varlist works
1774         with self.subTest():
1775             a = factory(GlobalFunc, varlist='XYZ')
1776             c = a.get_contents(target=[], source=[], env=Environment())
1777             self.assertEqual(c, func_matches[sys.version_info[:2]])
1778
1779         with self.subTest():
1780             c = a.get_contents(target=[], source=[], env=Environment(XYZ='foo'))
1781             self.assertIn(c, matches_foo)
1782
1783         class Foo:
1784             def get_contents(self, target, source, env) -> bytes:
1785                 return b'xyzzy'
1786
1787         with self.subTest():
1788             a = factory(Foo())
1789             c = a.get_contents(target=[], source=[], env=Environment())
1790             self.assertEqual(c, b'xyzzy')
1791
1792         class LocalClass:
1793             def LocalMethod(self) -> None:
1794                 pass
1795
1796         with self.subTest():
1797             lc = LocalClass()
1798             a = factory(lc.LocalMethod)
1799             c = a.get_contents(target=[], source=[], env=Environment())
1800             self.assertEqual(c, meth_matches[sys.version_info[:2]])
1801
1802     def test_strfunction(self) -> None:
1803         """Test the FunctionAction.strfunction() method."""
1804
1805         def func() -> None:
1806             pass
1807
1808         def factory(act, **kw):
1809             return SCons.Action.FunctionAction(act, kw)
1810
1811         a = factory(func)
1812         s = a.strfunction(target=[], source=[], env=Environment())
1813         assert s == 'func([], [])', s
1814
1815         a = factory(func, strfunction=None)
1816         s = a.strfunction(target=[], source=[], env=Environment())
1817         assert s is None, s
1818
1819         a = factory(func, cmdstr='function')
1820         s = a.strfunction(target=[], source=[], env=Environment())
1821         assert s == 'function', s
1822
1823
1824 class ListActionTestCase(unittest.TestCase):
1825
1826     def test___init__(self) -> None:
1827         """Test creation of a list of subsidiary Actions."""
1828
1829         def func() -> None:
1830             pass
1831
1832         a = SCons.Action.ListAction(["x", func, ["y", "z"]])
1833         assert isinstance(a.list[0], SCons.Action.CommandAction)
1834         assert isinstance(a.list[1], SCons.Action.FunctionAction)
1835         assert isinstance(a.list[2], SCons.Action.ListAction)
1836         assert a.list[2].list[0].cmd_list == 'y'
1837
1838     def test___str__(self) -> None:
1839         """Test the __str__() method for a list of subsidiary Actions."""
1840
1841         def f(target, source, env) -> None:
1842             pass
1843
1844         def g(target, source, env) -> None:
1845             pass
1846
1847         a = SCons.Action.ListAction([f, g, "XXX", f])
1848         s = str(a)
1849         assert s == "f(target, source, env)\ng(target, source, env)\nXXX\nf(target, source, env)", s
1850
1851     def test_genstring(self) -> None:
1852         """Test the genstring() method for a list of subsidiary Actions."""
1853
1854         def f(target, source, env) -> None:
1855             pass
1856
1857         def g(target, source, env, for_signature) -> str:
1858             return 'generated %s %s' % (target[0], source[0])
1859
1860         g = SCons.Action.Action(g, generator=1)
1861         a = SCons.Action.ListAction([f, g, "XXX", f])
1862         s = a.genstring(['foo.x'], ['bar.y'], Environment())
1863         assert s == "f(target, source, env)\ngenerated foo.x bar.y\nXXX\nf(target, source, env)", s
1864
1865     def test_execute(self) -> None:
1866         """Test executing a list of subsidiary Actions."""
1867         self.inc = 0
1868
1869         def f(target, source, env) -> None:
1870             s = env['s']
1871             s.inc = s.inc + 1
1872
1873         a = SCons.Action.ListAction([f, f, f])
1874         a([], [], Environment(s=self))
1875         assert self.inc == 3, self.inc
1876
1877         cmd2 = r'%s %s %s syzygy' % (_python_, act_py, outfile)
1878
1879         def function2(target, source, env) -> int:
1880             with open(env['out'], 'a') as f:
1881                 f.write("function2\n")
1882             return 0
1883
1884         class class2a:
1885             def __call__(self, target, source, env) -> int:
1886                 with open(env['out'], 'a') as f:
1887                     f.write("class2a\n")
1888                 return 0
1889
1890         class class2b:
1891             def __init__(self, target, source, env) -> None:
1892                 with open(env['out'], 'a') as f:
1893                     f.write("class2b\n")
1894
1895         act = SCons.Action.ListAction([cmd2, function2, class2a(), class2b])
1896         r = act([], [], Environment(out=outfile))
1897         assert isinstance(r.status, class2b), r.status
1898         c = test.read(outfile, 'r')
1899         assert c == "act.py: 'syzygy'\nfunction2\nclass2a\nclass2b\n", c
1900
1901     def test_get_contents(self) -> None:
1902         """Test fetching the contents of a list of subsidiary Actions."""
1903
1904         self.foo = 0
1905
1906         def gen(target, source, env, for_signature) -> str:
1907             s = env['s']
1908             s.foo = 1
1909             return "y"
1910
1911         a = SCons.Action.ListAction(["x",
1912                                      SCons.Action.Action(gen, generator=1),
1913                                      "z"])
1914         c = a.get_contents(target=[], source=[], env=Environment(s=self))
1915         assert self.foo == 1, self.foo
1916         assert c == b"xyz", c
1917
1918
1919 class LazyActionTestCase(unittest.TestCase):
1920     def test___init__(self) -> None:
1921         """Test creation of a lazy-evaluation Action."""
1922
1923         # Environment variable references should create a special type
1924         # of LazyAction that lazily evaluates the variable for whether
1925         # it's a string or something else before doing anything.
1926         a9 = SCons.Action.Action('$FOO')
1927         assert isinstance(a9, SCons.Action.LazyAction), a9
1928         assert a9.var == 'FOO', a9.var
1929
1930         a10 = SCons.Action.Action('${FOO}')
1931         assert isinstance(a10, SCons.Action.LazyAction), a10
1932         assert a10.var == 'FOO', a10.var
1933
1934     def test_genstring(self) -> None:
1935         """Test the lazy-evaluation Action genstring() method."""
1936
1937         def f(target, source, env) -> None:
1938             pass
1939
1940         a = SCons.Action.Action('$BAR')
1941         env1 = Environment(BAR=f, s=self)
1942         env2 = Environment(BAR='xxx', s=self)
1943         s = a.genstring([], [], env=env1)
1944         assert s == "f(target, source, env)", s
1945         s = a.genstring([], [], env=env2)
1946         assert s == 'xxx', s
1947
1948     def test_execute(self) -> None:
1949         """Test executing a lazy-evaluation Action."""
1950
1951         def f(target, source, env) -> int:
1952             s = env['s']
1953             s.test = 1
1954             return 0
1955
1956         a = SCons.Action.Action('$BAR')
1957         a([], [], env=Environment(BAR=f, s=self))
1958         assert self.test == 1, self.test
1959         cmd = r'%s %s %s lazy' % (_python_, act_py, outfile)
1960         a([], [], env=Environment(BAR=cmd, s=self))
1961         c = test.read(outfile, 'r')
1962         assert c == "act.py: 'lazy'\n", c
1963
1964     def test_get_contents(self) -> None:
1965         """Test fetching the contents of a lazy-evaluation Action."""
1966
1967         a = SCons.Action.Action("${FOO}")
1968         env = Environment(FOO=[["This", "is", "a", "test"]])
1969         c = a.get_contents(target=[], source=[], env=env)
1970         assert c == b"This is a test", c
1971
1972     def test_get_contents_of_function_action(self) -> None:
1973         """Test fetching the contents of a lazy-evaluation FunctionAction."""
1974
1975         def LocalFunc() -> None:
1976             pass
1977
1978         func_matches = {
1979             (3, 7): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1980             (3, 8): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1981             (3, 9): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1982             (3, 10): bytearray(b'0, 0, 0, 0,(),(),(d\x00S\x00),(),()'),
1983             (3, 11): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00d\x00S\x00),(),()'),
1984             (3, 12): bytearray(b'0, 0, 0, 0,(),(),(\x97\x00y\x00),(),()'),
1985             (3, 13): bytearray(b'0, 0, 0, 0,(),(),(\x95\x00g\x00),(),()'),
1986         }
1987
1988         meth_matches = [
1989             b"1, 1, 0, 0,(),(),(d\000\000S),(),()",
1990             b"1, 1, 0, 0,(),(),(d\x00\x00S),(),()",
1991         ]
1992
1993         def factory(act, **kw):
1994             return SCons.Action.FunctionAction(act, kw)
1995
1996         a = SCons.Action.Action("${FOO}")
1997
1998         with self.subTest():
1999             env = Environment(FOO=factory(GlobalFunc))
2000             c = a.get_contents(target=[], source=[], env=env)
2001             self.assertEqual(c, func_matches[sys.version_info[:2]])
2002
2003         with self.subTest():
2004             env = Environment(FOO=factory(LocalFunc))
2005             c = a.get_contents(target=[], source=[], env=env)
2006             self.assertEqual(c, func_matches[sys.version_info[:2]])
2007
2008         # matches_foo = [x + b"foo" for x in func_matches]
2009         matches_foo = func_matches[sys.version_info[:2]] + b'foo'
2010
2011         with self.subTest():
2012             env = Environment(FOO=factory(GlobalFunc, varlist=['XYZ']))
2013             c = a.get_contents(target=[], source=[], env=env)
2014             self.assertEqual(c, func_matches[sys.version_info[:2]])
2015
2016         with self.subTest():
2017             env['XYZ'] = 'foo'
2018             c = a.get_contents(target=[], source=[], env=env)
2019             self.assertIn(c, matches_foo)
2020
2021
2022 class ActionCallerTestCase(unittest.TestCase):
2023     def test___init__(self) -> None:
2024         """Test creation of an ActionCaller"""
2025
2026         ac = SCons.Action.ActionCaller(1, [2, 3], {'FOO': 4, 'BAR': 5})
2027         assert ac.parent == 1, ac.parent
2028         assert ac.args == [2, 3], ac.args
2029         assert ac.kw == {'FOO': 4, 'BAR': 5}, ac.kw
2030
2031     def test_get_contents(self) -> None:
2032         """Test fetching the contents of an ActionCaller"""
2033
2034         def strfunc() -> None:
2035             pass
2036
2037         def LocalFunc() -> None:
2038             pass
2039
2040         matches = {
2041             (3, 7): b'd\x00S\x00',
2042             (3, 8): b'd\x00S\x00',
2043             (3, 9): b'd\x00S\x00',
2044             (3, 10): b'd\x00S\x00',
2045             (3, 11): b'\x97\x00d\x00S\x00',
2046             (3, 12): b'\x97\x00y\x00',
2047             (3, 13): b'\x95\x00g\x00',
2048         }
2049
2050         with self.subTest():
2051             af = SCons.Action.ActionFactory(GlobalFunc, strfunc)
2052             ac = SCons.Action.ActionCaller(af, [], {})
2053             c = ac.get_contents([], [], Environment())
2054             self.assertEqual(c, matches[sys.version_info[:2]])
2055
2056         with self.subTest():
2057             af = SCons.Action.ActionFactory(LocalFunc, strfunc)
2058             ac = SCons.Action.ActionCaller(af, [], {})
2059             c = ac.get_contents([], [], Environment())
2060             self.assertEqual(c, matches[sys.version_info[:2]])
2061
2062         class LocalActFunc:
2063             def __call__(self) -> None:
2064                 pass
2065
2066         with self.subTest():
2067             af = SCons.Action.ActionFactory(GlobalActFunc(), strfunc)
2068             ac = SCons.Action.ActionCaller(af, [], {})
2069             c = ac.get_contents([], [], Environment())
2070             self.assertEqual(c, matches[sys.version_info[:2]])
2071
2072         with self.subTest():
2073             af = SCons.Action.ActionFactory(LocalActFunc(), strfunc)
2074             ac = SCons.Action.ActionCaller(af, [], {})
2075             c = ac.get_contents([], [], Environment())
2076             self.assertEqual(c, matches[sys.version_info[:2]])
2077
2078         matches = [
2079             b"<built-in function str>",
2080             b"<type 'str'>",
2081         ]
2082
2083         with self.subTest():
2084             af = SCons.Action.ActionFactory(str, strfunc)
2085             ac = SCons.Action.ActionCaller(af, [], {})
2086             c = ac.get_contents([], [], Environment())
2087             self.assertIn(c, ("<built-in function str>", "<type 'str'>", "<class 'str'>"))
2088             # ^^ class str for python3
2089
2090     def test___call__(self) -> None:
2091         """Test calling an ActionCaller"""
2092
2093         actfunc_args = []
2094
2095         def actfunc(a1, a2, a3, args=actfunc_args) -> None:
2096             args.extend([a1, a2, a3])
2097
2098         def strfunc(a1, a2, a3) -> None:
2099             pass
2100
2101         e = Environment(FOO=2, BAR=5)
2102
2103         af = SCons.Action.ActionFactory(actfunc, strfunc)
2104         ac = SCons.Action.ActionCaller(af, ['$__env__', '$FOO', 3], {})
2105         ac([], [], e)
2106         assert actfunc_args[0] is e, actfunc_args
2107         assert actfunc_args[1] == '2', actfunc_args
2108         assert actfunc_args[2] == 3, actfunc_args
2109         del actfunc_args[:]
2110
2111         ac = SCons.Action.ActionCaller(af, [], {'a3': '$__env__', 'a2': '$BAR', 'a1': 4})
2112         ac([], [], e)
2113         assert actfunc_args[0] == 4, actfunc_args
2114         assert actfunc_args[1] == '5', actfunc_args
2115         assert actfunc_args[2] is e, actfunc_args
2116         del actfunc_args[:]
2117
2118     def test_strfunction(self) -> None:
2119         """Test calling the ActionCaller strfunction() method"""
2120
2121         strfunc_args = []
2122
2123         def actfunc(a1, a2, a3, a4) -> None:
2124             pass
2125
2126         def strfunc(a1, a2, a3, a4, args=strfunc_args) -> None:
2127             args.extend([a1, a2, a3, a4])
2128
2129         af = SCons.Action.ActionFactory(actfunc, strfunc)
2130         ac = SCons.Action.ActionCaller(af, [1, '$FOO', 3, '$WS'], {})
2131         ac.strfunction([], [], Environment(FOO=2, WS='white   space'))
2132         assert strfunc_args == [1, '2', 3, 'white   space'], strfunc_args
2133
2134         del strfunc_args[:]
2135         d = {'a3': 6, 'a2': '$BAR', 'a1': 4, 'a4': '$WS'}
2136         ac = SCons.Action.ActionCaller(af, [], d)
2137         ac.strfunction([], [], Environment(BAR=5, WS='w   s'))
2138         assert strfunc_args == [4, '5', 6, 'w   s'], strfunc_args
2139
2140
2141 class ActionFactoryTestCase(unittest.TestCase):
2142     def test___init__(self) -> None:
2143         """Test creation of an ActionFactory"""
2144
2145         def actfunc() -> None:
2146             pass
2147
2148         def strfunc() -> None:
2149             pass
2150
2151         ac = SCons.Action.ActionFactory(actfunc, strfunc)
2152         assert ac.actfunc is actfunc, ac.actfunc
2153         assert ac.strfunc is strfunc, ac.strfunc
2154
2155     def test___call__(self) -> None:
2156         """Test calling whatever's returned from an ActionFactory"""
2157
2158         actfunc_args = []
2159         strfunc_args = []
2160
2161         def actfunc(a1, a2, a3, args=actfunc_args) -> None:
2162             args.extend([a1, a2, a3])
2163
2164         def strfunc(a1, a2, a3, args=strfunc_args) -> None:
2165             args.extend([a1, a2, a3])
2166
2167         af = SCons.Action.ActionFactory(actfunc, strfunc)
2168         af(3, 6, 9)([], [], Environment())
2169         assert actfunc_args == [3, 6, 9], actfunc_args
2170         assert strfunc_args == [3, 6, 9], strfunc_args
2171
2172
2173 class ActionCompareTestCase(unittest.TestCase):
2174     def test_1_solo_name(self) -> None:
2175         """Test Lazy Cmd Generator Action get_name alone.
2176
2177         Basically ensures we can locate the builder, comparing it to
2178         itself along the way."""
2179
2180         bar = SCons.Builder.Builder(action={})
2181         env = Environment(BUILDERS={'BAR': bar})
2182         name = bar.get_name(env)
2183         assert name == 'BAR', name
2184
2185     def test_2_multi_name(self) -> None:
2186         """Test LazyCmdGenerator Action get_name multi builders.
2187
2188         Ensure that we can compare builders (and thereby actions) to
2189         each other safely."""
2190
2191         foo = SCons.Builder.Builder(action='$FOO', suffix='.foo')
2192         bar = SCons.Builder.Builder(action={})
2193         assert foo != bar
2194         assert foo.action != bar.action
2195         env = Environment(BUILDERS={'FOO': foo, 'BAR': bar})
2196         name = foo.get_name(env)
2197         assert name == 'FOO', name
2198         name = bar.get_name(env)
2199         assert name == 'BAR', name
2200
2201     def test_3_dict_names(self) -> None:
2202         """Test Action/Suffix dicts with get_name.
2203
2204         Verifies that Action/Suffix dictionaries work correctly,
2205         especially two builders that can generate the same suffix,
2206         where one of the builders has a suffix dictionary with a None
2207         key."""
2208
2209         foo = SCons.Builder.Builder(action='$FOO', suffix='.foo')
2210         bar = SCons.Builder.Builder(action={}, suffix={None: '.bar'})
2211         bar.add_action('.cow', "$MOO")
2212         dog = SCons.Builder.Builder(suffix='.bar')
2213         env = Environment(BUILDERS={'FOO': foo, 'BAR': bar, 'DOG': dog})
2214
2215         assert foo.get_name(env) == 'FOO', foo.get_name(env)
2216         assert bar.get_name(env) == 'BAR', bar.get_name(env)
2217         assert dog.get_name(env) == 'DOG', dog.get_name(env)
2218
2219
2220 class TestClass:
2221     """A test class used by ObjectContentsTestCase.test_object_contents"""
2222
2223     def __init__(self) -> None:
2224         self.a = "a"
2225         self.b = "b"
2226
2227     def method(self, arg) -> None:
2228         pass
2229
2230
2231 class ObjectContentsTestCase(unittest.TestCase):
2232     def test_function_contents(self) -> None:
2233         """Test that Action._function_contents works"""
2234
2235         def func1(a, b, c):
2236             """A test function"""
2237             return a
2238
2239         # Since the python bytecode has per version differences,
2240         # we need different expected results per version
2241         # Note unlike the others, this result is a tuple, use assertIn
2242         expected = {
2243             (3, 7): (bytearray(b'3, 3, 0, 0,(),(),(|\x00S\x00),(),()'),),
2244             (3, 8): (bytearray(b'3, 3, 0, 0,(),(),(|\x00S\x00),(),()'),),
2245             (3, 9): (bytearray(b'3, 3, 0, 0,(),(),(|\x00S\x00),(),()'),),
2246             (3, 10): (  # 3.10.1, 3.10.2
2247                 bytearray(b'3, 3, 0, 0,(N.),(),(|\x00S\x00),(),()'),
2248                 bytearray(b'3, 3, 0, 0,(),(),(|\x00S\x00),(),()'),
2249             ),
2250             (3, 11): (bytearray(b'3, 3, 0, 0,(),(),(\x97\x00|\x00S\x00),(),()'),),
2251             (3, 12): (bytearray(b'3, 3, 0, 0,(),(),(\x97\x00|\x00S\x00),(),()'),),
2252             (3, 13): (bytearray(b'3, 3, 0, 0,(),(),(\x95\x00U\x00$\x00),(),()'),),
2253         }
2254
2255         c = SCons.Action._function_contents(func1)
2256         self.assertIn(c, expected[sys.version_info[:2]])
2257
2258     def test_object_contents(self) -> None:
2259         """Test that Action._object_contents works"""
2260
2261         # See definition above
2262         o = TestClass()
2263         c = SCons.Action._object_contents(o)
2264
2265         # c = SCons.Action._object_instance_content(o)
2266
2267         # Since the python bytecode has per version differences,
2268         # we need different expected results per version
2269         expected = {
2270             (3, 7): bytearray(
2271                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(d\x01|\x00_\x00d\x02|\x00_\x01d\x00S\x00),(),(),2, 2, 0, 0,(),(),(d\x00S\x00),(),()}}{{{a=a,b=b}}}"
2272             ),
2273             (3, 8): bytearray(
2274                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(d\x01|\x00_\x00d\x02|\x00_\x01d\x00S\x00),(),(),2, 2, 0, 0,(),(),(d\x00S\x00),(),()}}{{{a=a,b=b}}}"
2275             ),
2276             (3, 9): bytearray(
2277                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(d\x01|\x00_\x00d\x02|\x00_\x01d\x00S\x00),(),(),2, 2, 0, 0,(),(),(d\x00S\x00),(),()}}{{{a=a,b=b}}}"
2278             ),
2279             (3, 10): bytearray(
2280                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(d\x01|\x00_\x00d\x02|\x00_\x01d\x00S\x00),(),(),2, 2, 0, 0,(),(),(d\x00S\x00),(),()}}{{{a=a,b=b}}}"
2281             ),
2282             (3, 11): bytearray(
2283                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(\x97\x00d\x01|\x00_\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x02|\x00_\x01\x00\x00\x00\x00\x00\x00\x00\x00d\x00S\x00),(),(),2, 2, 0, 0,(),(),(\x97\x00d\x00S\x00),(),()}}{{{a=a,b=b}}}"
2284             ),
2285             (3, 12): bytearray(
2286                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(\x97\x00d\x01|\x00_\x00\x00\x00\x00\x00\x00\x00\x00\x00d\x02|\x00_\x01\x00\x00\x00\x00\x00\x00\x00\x00y\x00),(),(),2, 2, 0, 0,(),(),(\x97\x00y\x00),(),()}}{{{a=a,b=b}}}"
2287             ),
2288             (3, 13): bytearray(
2289                 b"{TestClass:__main__}[[[(<class \'object\'>, ()), [(<class \'__main__.TestClass\'>, (<class \'object\'>,))]]]]{{1, 1, 0, 0,(a,b),(a,b),(\x95\x00S\x01U\x00l\x00\x00\x00\x00\x00\x00\x00\x00\x00S\x02U\x00l\x01\x00\x00\x00\x00\x00\x00\x00\x00g\x00),(),(),2, 2, 0, 0,(),(),(\x95\x00g\x00),(),()}}{{{a=a,b=b}}}"
2290             ),
2291         }
2292
2293         self.assertEqual(c, expected[sys.version_info[:2]])
2294
2295     def test_code_contents(self) -> None:
2296         """Test that Action._code_contents works"""
2297
2298         code = compile("print('Hello, World!')", '<string>', 'exec')
2299         c = SCons.Action._code_contents(code)
2300
2301         # Since the python bytecode has per version differences, we need different expected results per version
2302         expected = {
2303             (3, 7): bytearray(
2304                 b'0, 0, 0, 0,(Hello, World!),(print),(e\x00d\x00\x83\x01\x01\x00d\x01S\x00)'
2305             ),
2306             (3, 8): bytearray(
2307                 b'0, 0, 0, 0,(Hello, World!),(print),(e\x00d\x00\x83\x01\x01\x00d\x01S\x00)'
2308             ),
2309             (3, 9): bytearray(
2310                 b'0, 0, 0, 0,(Hello, World!),(print),(e\x00d\x00\x83\x01\x01\x00d\x01S\x00)'
2311             ),
2312             (3, 10): bytearray(
2313                 b'0, 0, 0, 0,(Hello, World!),(print),(e\x00d\x00\x83\x01\x01\x00d\x01S\x00)'
2314             ),
2315             (3, 11): bytearray(
2316                 b'0, 0, 0, 0,(Hello, World!),(print),(\x97\x00\x02\x00e\x00d\x00\xa6\x01\x00\x00\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00d\x01S\x00)'
2317             ),
2318             (3, 12): bytearray(
2319                 b'0, 0, 0, 0,(Hello, World!),(print),(\x97\x00\x02\x00e\x00d\x00\xab\x01\x00\x00\x00\x00\x00\x00\x01\x00y\x01)'
2320             ),
2321             (3, 13): bytearray(
2322                 b'0, 0, 0, 0,(Hello, World!),(print),(\x95\x00\\\x00"\x00S\x005\x01\x00\x00\x00\x00\x00\x00 \x00g\x01)'
2323             ),
2324         }
2325
2326         self.assertEqual(c, expected[sys.version_info[:2]])
2327
2328     def test_uncaught_exception_bubbles(self):
2329         """Test that scons_subproc_run bubbles uncaught exceptions"""
2330         try:
2331             cp = scons_subproc_run(Environment(), None, stdout=PIPE)
2332         except EnvironmentError:
2333             pass
2334         except Exception:
2335             # pass the test
2336             return
2337
2338         raise Exception("expected a non-EnvironmentError exception")
2339
2340
2341     def mock_subprocess_run(*args, **kwargs):
2342         """Replacement subprocess.run: return kwargs for checking."""
2343         kwargs.pop("env")  # the value of env isn't interesting here
2344         return kwargs
2345
2346     @mock.patch("subprocess.run", mock_subprocess_run)
2347     def test_scons_subproc_run(self):
2348         """Test the argument remapping options."""
2349         # set phony Python versions to trigger the logic in scons_subproc_run:
2350         # any version greater than 3.6, really
2351         save_info, sys.version_info = sys.version_info, (3, 11, 1)
2352         env = Environment()
2353         self.assertEqual(scons_subproc_run(env), {"check": False})
2354         with self.subTest():
2355             self.assertEqual(
2356                 scons_subproc_run(env, error="raise"),
2357                 {"check": True}
2358             )
2359         with self.subTest():
2360             self.assertEqual(
2361                 scons_subproc_run(env, capture_output=True),
2362                 {"capture_output": True, "check": False},
2363             )
2364         with self.subTest():
2365             self.assertEqual(
2366                 scons_subproc_run(env, text=True),
2367                 {"text": True, "check": False},
2368             )
2369
2370         # 3.7:
2371         sys.version_info = (3, 7, 2)
2372         with self.subTest():
2373             self.assertEqual(
2374                 scons_subproc_run(env, capture_output=True),
2375                 {"capture_output": True, "check": False},
2376             )
2377         with self.subTest():
2378             self.assertEqual(
2379                 scons_subproc_run(env, text=True),
2380                 {"check": False, "text": True},
2381             )
2382         with self.subTest():
2383             self.assertEqual(
2384                 scons_subproc_run(env, universal_newlines=True),
2385                 {"universal_newlines": True, "check": False},
2386             )
2387         sys.version_info = save_info
2388
2389
2390 if __name__ == "__main__":
2391     unittest.main()
2392
2393 # Local Variables:
2394 # tab-width:4
2395 # indent-tabs-mode:nil
2396 # End:
2397 # vim: set expandtab tabstop=4 shiftwidth=4: