testing/framework/TestCommonTests.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2000-2010 Steven Knight
   4 #
   5 # This module is free software, and you may redistribute it and/or modify
   6 # it under the same terms as Python itself, so long as this copyright message
   7 # and disclaimer are retained in their original form.
   8 #
   9 # IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
  10 # SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
  11 # THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  12 # DAMAGE.
  13 #
  14 # THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
  15 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  16 # PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
  17 # AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
  18 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  19 #
  20 # Python License: https://docs.python.org/3/license.html#psf-license
  21
  22 """
  23 Unit tests for the TestCommon.py module.
  24 """
  25
  26 import os
  27 import re
  28 import signal
  29 import sys
  30 import unittest
  31 from textwrap import dedent
  32
  33 # Strip the current directory so we get the right TestCommon.py module.
  34 sys.path = sys.path[1:]
  35
  36 import TestCmd
  37 import TestCommon
  38
  39 # this used to be a custom function, now use the stdlib equivalent
  40 def lstrip(s):
  41     return dedent(s)
  42
  43 expected_newline = '\\n'
  44
  45
  46 def assert_display(expect, result, error=None):
  47     try:
  48         expect = expect.pattern
  49     except AttributeError:
  50         pass
  51     display = [
  52         '\n',
  53         f"{'EXPECTED: ':*<80}\n",
  54         expect,
  55         f"{'GOT: ':*<80}\n",
  56         result,
  57         '' if error is None else error,
  58         f"{'':*<80}\n",
  59     ]
  60     return ''.join(display)
  61
  62
  63 class TestCommonTestCase(unittest.TestCase):
  64     """Base class for TestCommon test cases, fixture and utility methods."""
  65     create_run_env = True
  66
  67     def setUp(self) -> None:
  68         self.orig_cwd = os.getcwd()
  69         if self.create_run_env:
  70             self.run_env = TestCmd.TestCmd(workdir = '')
  71
  72     def tearDown(self) -> None:
  73         os.chdir(self.orig_cwd)
  74
  75     def set_up_execution_scripts(self) -> None:
  76         run_env = self.run_env
  77
  78         run_env.subdir('sub dir')
  79
  80         self.python = sys.executable
  81
  82         self.pass_script = run_env.workpath('sub dir', 'pass')
  83         self.fail_script = run_env.workpath('sub dir', 'fail')
  84         self.stdout_script = run_env.workpath('sub dir', 'stdout')
  85         self.stderr_script = run_env.workpath('sub dir', 'stderr')
  86         self.signal_script = run_env.workpath('sub dir', 'signal')
  87         self.stdin_script = run_env.workpath('sub dir', 'stdin')
  88
  89         preamble = "import sys"
  90         stdout = "; sys.stdout.write(r'%s:  STDOUT:  ' + repr(sys.argv[1:]) + '\\n')"
  91         stderr = "; sys.stderr.write(r'%s:  STDERR:  ' + repr(sys.argv[1:]) + '\\n')"
  92         exit0 = "; sys.exit(0)"
  93         exit1 = "; sys.exit(1)"
  94         if sys.platform == 'win32':
  95             wrapper = '@python -c "%s" %%1 %%2 %%3 %%4 %%5 %%6 %%7 %%8 %%9\n'
  96         else:
  97             wrapper = '#! /usr/bin/env python\n%s\n'
  98         wrapper = '#! /usr/bin/env python\n%s\n'
  99
 100         pass_body = preamble + stdout % self.pass_script + exit0
 101         fail_body = preamble + stdout % self.fail_script + exit1
 102         stderr_body = preamble + stderr % self.stderr_script + exit0
 103
 104         run_env.write(self.pass_script, wrapper % pass_body)
 105         run_env.write(self.fail_script, wrapper % fail_body)
 106         run_env.write(self.stderr_script, wrapper % stderr_body)
 107
 108         signal_body = lstrip("""\
 109         import os
 110         import signal
 111         os.kill(os.getpid(), signal.SIGTERM)
 112         """)
 113
 114         run_env.write(self.signal_script, wrapper % signal_body)
 115
 116         stdin_body = lstrip("""\
 117         import sys
 118         input = sys.stdin.read()[:-1]
 119         sys.stdout.write(r'%s:  STDOUT:  ' + repr(input) + '\\n')
 120         sys.stderr.write(r'%s:  STDERR:  ' + repr(input) + '\\n')
 121         """ % (self.stdin_script, self.stdin_script))
 122
 123         run_env.write(self.stdin_script, wrapper % stdin_body)
 124
 125     def run_execution_test(self, script, expect_stdout, expect_stderr) -> None:
 126         self.set_up_execution_scripts()
 127
 128         run_env = self.run_env
 129
 130         os.chdir(run_env.workpath('sub dir'))
 131
 132         # Everything before this prepared our "source directory."
 133         # Now do the real test.
 134         script = script % self.__dict__
 135         run_env.run(program=sys.executable, stdin=script)
 136
 137         stdout = run_env.stdout()
 138         stderr = run_env.stderr()
 139
 140         expect_stdout = expect_stdout % self.__dict__
 141         assert stdout == expect_stdout, assert_display(expect_stdout,
 142                                                        stdout,
 143                                                        stderr)
 144
 145         try:
 146             match = expect_stderr.match
 147         except AttributeError:
 148             expect_stderr = expect_stderr % self.__dict__
 149             assert stderr == expect_stderr, assert_display(expect_stderr,
 150                                                            stderr)
 151         else:
 152             assert expect_stderr.match(stderr), assert_display(expect_stderr,
 153                                                                stderr)
 154
 155
 156 class __init__TestCase(TestCommonTestCase):
 157     def test___init__(self) -> None:
 158         """Test initialization"""
 159         run_env = self.run_env
 160
 161         os.chdir(run_env.workdir)
 162         script = lstrip("""\
 163         from TestCommon import TestCommon
 164         tc = TestCommon(workdir='')
 165         import os
 166         print(os.getcwd())
 167         """)
 168         run_env.run(program=sys.executable, stdin=script)
 169         stdout = run_env.stdout()[:-1]
 170         assert stdout != run_env.workdir, stdout
 171         stderr = run_env.stderr()
 172         assert stderr == "", stderr
 173
 174
 175 class banner_TestCase(TestCommonTestCase):
 176     create_run_env = False
 177     def test_banner(self) -> None:
 178         """Test banner()"""
 179         tc = TestCommon.TestCommon(workdir='')
 180
 181         b = tc.banner('xyzzy ')
 182         assert b == "xyzzy ==========================================================================", b
 183
 184         tc.banner_width = 10
 185
 186         b = tc.banner('xyzzy ')
 187         assert b == "xyzzy ====", b
 188
 189         b = tc.banner('xyzzy ', 20)
 190         assert b == "xyzzy ==============", b
 191
 192         tc.banner_char = '-'
 193
 194         b = tc.banner('xyzzy ')
 195         assert b == "xyzzy ----", b
 196
 197 class must_be_writable_TestCase(TestCommonTestCase):
 198     def test_file_does_not_exists(self) -> None:
 199         """Test must_be_writable():  file does not exist"""
 200         run_env = self.run_env
 201
 202         script = lstrip("""\
 203         from TestCommon import TestCommon
 204         tc = TestCommon(workdir='')
 205         tc.must_be_writable('file1')
 206         tc.pass_test()
 207         """)
 208         run_env.run(program=sys.executable, stdin=script)
 209         stdout = run_env.stdout()
 210         assert stdout == "Missing files: `file1'\n", stdout
 211         stderr = run_env.stderr()
 212         assert stderr.find("FAILED") != -1, stderr
 213
 214     def test_writable_file_exists(self) -> None:
 215         """Test must_be_writable():  writable file exists"""
 216         run_env = self.run_env
 217
 218         script = lstrip("""\
 219         import os
 220         import stat
 221         from TestCommon import TestCommon
 222         tc = TestCommon(workdir='')
 223         tc.write('file1', "file1\\n")
 224         f1 = tc.workpath('file1')
 225         mode = os.stat(f1).st_mode
 226         os.chmod(f1, mode | stat.S_IWUSR)
 227         tc.must_be_writable('file1')
 228         tc.pass_test()
 229         """)
 230         run_env.run(program=sys.executable, stdin=script)
 231         stdout = run_env.stdout()
 232         assert stdout == "", stdout
 233         stderr = run_env.stderr()
 234         assert stderr == "PASSED\n", stderr
 235
 236     def test_non_writable_file_exists(self) -> None:
 237         """Test must_be_writable():  non-writable file exists"""
 238         run_env = self.run_env
 239
 240         script = lstrip("""\
 241         import os
 242         import stat
 243         from TestCommon import TestCommon
 244         tc = TestCommon(workdir='')
 245         tc.write('file1', "file1\\n")
 246         f1 = tc.workpath('file1')
 247         mode = os.stat(f1).st_mode
 248         os.chmod(f1, mode & ~stat.S_IWUSR)
 249         tc.must_be_writable('file1')
 250         tc.pass_test()
 251         """)
 252         run_env.run(program=sys.executable, stdin=script)
 253         stdout = run_env.stdout()
 254         assert stdout == "Unwritable files: `file1'\n", stdout
 255         stderr = run_env.stderr()
 256         assert stderr.find("FAILED") != -1, stderr
 257
 258     def test_file_specified_as_list(self) -> None:
 259         """Test must_be_writable():  file specified as list"""
 260         run_env = self.run_env
 261
 262         script = lstrip("""\
 263         import os
 264         import stat
 265         from TestCommon import TestCommon
 266         tc = TestCommon(workdir='')
 267         tc.subdir('sub')
 268         tc.write(['sub', 'file1'], "sub/file1\\n")
 269         f1 = tc.workpath('sub', 'file1')
 270         mode = os.stat(f1).st_mode
 271         os.chmod(f1, mode | stat.S_IWUSR)
 272         tc.must_be_writable(['sub', 'file1'])
 273         tc.pass_test()
 274         """)
 275         run_env.run(program=sys.executable, stdin=script)
 276         stdout = run_env.stdout()
 277         assert stdout == "", stdout
 278         stderr = run_env.stderr()
 279         assert stderr == "PASSED\n", stderr
 280
 281
 282 class must_contain_TestCase(TestCommonTestCase):
 283     def test_success(self) -> None:
 284         """Test must_contain():  success"""
 285         run_env = self.run_env
 286
 287         script = lstrip("""\
 288         from TestCommon import TestCommon
 289         tc = TestCommon(workdir='')
 290         tc.write('file1', "file1 contents\\n")
 291         tc.must_contain('file1', "1 c")
 292         tc.pass_test()
 293         """)
 294         run_env.run(program=sys.executable, stdin=script)
 295         stdout = run_env.stdout()
 296         assert stdout == "", stdout
 297         stderr = run_env.stderr()
 298         assert stderr == "PASSED\n", stderr
 299
 300     def test_success_index_0(self) -> None:
 301         """Test must_contain():  success at index 0"""
 302         run_env = self.run_env
 303
 304         script = lstrip("""\
 305         from TestCommon import TestCommon
 306         tc = TestCommon(workdir='')
 307         tc.write('file1', "file1 contents\\n")
 308         tc.must_contain('file1', "file1 c")
 309         tc.pass_test()
 310         """)
 311         run_env.run(program=sys.executable, stdin=script)
 312         stdout = run_env.stdout()
 313         assert stdout == "", stdout
 314         stderr = run_env.stderr()
 315         assert stderr == "PASSED\n", stderr
 316
 317     def test_file_missing(self) -> None:
 318         """Test must_contain():  file missing"""
 319         run_env = self.run_env
 320
 321         script = lstrip("""\
 322         from TestCommon import TestCommon
 323         tc = TestCommon(workdir='')
 324         tc.must_contain('file1', "1 c\\n")
 325         tc.pass_test()
 326         """)
 327         run_env.run(program=sys.executable, stdin=script)
 328         stdout = run_env.stdout()
 329         assert stdout == "", stdout
 330         stderr = run_env.stderr()
 331         assert stderr.find("No such file or directory:") != -1, stderr
 332
 333     def test_failure(self) -> None:
 334         """Test must_contain():  failure"""
 335         run_env = self.run_env
 336
 337         script = lstrip("""\
 338         from TestCommon import TestCommon
 339         tc = TestCommon(workdir='')
 340         tc.write('file1', "file1 does not match\\n")
 341         tc.must_contain('file1', "1 c")
 342         tc.run()
 343         """)
 344         expect = lstrip("""\
 345         File `file1' does not contain required string.
 346         Required string ================================================================
 347         b'1 c'
 348         file1 contents =================================================================
 349         b'file1 does not match\\n'
 350         """)
 351         run_env.run(program=sys.executable, stdin=script)
 352         stdout = run_env.stdout()
 353         assert stdout == expect, f"got:\n{stdout}\nexpected:\n{expect}"
 354         stderr = run_env.stderr()
 355         assert stderr.find("FAILED") != -1, stderr
 356
 357     def test_mode(self) -> None:
 358         """Test must_contain():  mode"""
 359         run_env = self.run_env
 360
 361         script = lstrip("""\
 362         from TestCommon import TestCommon
 363         tc = TestCommon(workdir='')
 364         tc.write('file1', "file1 contents\\n", mode='w')
 365         tc.must_contain('file1', "1 c", mode='r')
 366         tc.write('file2', "file2 contents\\n", mode='wb')
 367         tc.must_contain('file2', "2 c", mode='rb')
 368         tc.pass_test()
 369         """)
 370         run_env.run(program=sys.executable, stdin=script)
 371         stdout = run_env.stdout()
 372         assert stdout == "", stdout
 373         stderr = run_env.stderr()
 374         assert stderr == "PASSED\n", stderr
 375
 376
 377
 378 class must_contain_all_lines_TestCase(TestCommonTestCase):
 379     def test_success(self) -> None:
 380         """Test must_contain_all_lines():  success"""
 381         run_env = self.run_env
 382
 383         script = lstrip("""
 384         import TestCommon
 385         test = TestCommon.TestCommon(workdir='')
 386
 387         lines = [
 388             'xxx\\n',
 389             'yyy\\n',
 390         ]
 391
 392         output = '''\\
 393         www
 394         xxx
 395         yyy
 396         zzz
 397         '''
 398
 399         test.must_contain_all_lines(output, lines)
 400
 401         test.must_contain_all_lines(output, ['www\\n'])
 402
 403         test.pass_test()
 404         """)
 405
 406         run_env.run(program=sys.executable, stdin=script)
 407         stdout = run_env.stdout()
 408         assert stdout == "", stdout
 409         stderr = run_env.stderr()
 410         assert stderr == "PASSED\n", stderr
 411
 412     def test_failure(self) -> None:
 413         """Test must_contain_all_lines():  failure"""
 414         run_env = self.run_env
 415
 416         script = lstrip("""
 417         import TestCommon
 418         test = TestCommon.TestCommon(workdir='')
 419
 420         lines = [
 421             'xxx\\n',
 422             'yyy\\n',
 423         ]
 424
 425         output = '''\\
 426         www
 427         zzz
 428         '''
 429
 430         test.must_contain_all_lines(output, lines)
 431
 432         test.pass_test()
 433         """)
 434
 435         expect = lstrip("""\
 436         Missing expected lines from output:
 437             'xxx%(expected_newline)s'
 438             'yyy%(expected_newline)s'
 439         output =========================================================================
 440         www
 441         zzz
 442         """ % globals())
 443
 444         run_env.run(program=sys.executable, stdin=script)
 445         stdout = run_env.stdout()
 446         stderr = run_env.stderr()
 447         assert stdout == expect, assert_display(expect, stdout, stderr)
 448         assert stderr.find("FAILED") != -1, stderr
 449
 450     def test_find(self) -> None:
 451         """Test must_contain_all_lines():  find"""
 452         run_env = self.run_env
 453
 454         script = lstrip("""
 455         import re
 456         import TestCommon
 457         test = TestCommon.TestCommon(workdir='')
 458
 459         lines = [
 460             'x.*',
 461             '.*y',
 462         ]
 463
 464         output = '''\\
 465         www
 466         xxx
 467         yyy
 468         zzz
 469         '''
 470
 471         def re_search(output, line):
 472             return re.compile(line, re.S).search(output)
 473
 474         test.must_contain_all_lines(output, lines, find=re_search)
 475
 476         test.pass_test()
 477         """)
 478
 479         run_env.run(program=sys.executable, stdin=script)
 480         stdout = run_env.stdout()
 481         assert stdout == "", stdout
 482         stderr = run_env.stderr()
 483         assert stderr == "PASSED\n", stderr
 484
 485     def test_title(self) -> None:
 486         """Test must_contain_all_lines():  title"""
 487         run_env = self.run_env
 488
 489         script = lstrip("""
 490         import TestCommon
 491         test = TestCommon.TestCommon(workdir='')
 492
 493         lines = [
 494             'xxx\\n',
 495             'yyy\\n',
 496         ]
 497
 498         output = '''\\
 499         www
 500         zzz
 501         '''
 502
 503         test.must_contain_all_lines(output, lines, title='STDERR')
 504
 505         test.pass_test()
 506         """)
 507
 508         expect = lstrip("""\
 509         Missing expected lines from STDERR:
 510             'xxx%(expected_newline)s'
 511             'yyy%(expected_newline)s'
 512         STDERR =========================================================================
 513         www
 514         zzz
 515         """ % globals())
 516
 517         run_env.run(program=sys.executable, stdin=script)
 518         stdout = run_env.stdout()
 519         stderr = run_env.stderr()
 520         assert stdout == expect, assert_display(expect, stdout, stderr)
 521         assert stderr.find("FAILED") != -1, stderr
 522
 523
 524
 525 class must_contain_any_line_TestCase(TestCommonTestCase):
 526     def test_success(self) -> None:
 527         """Test must_contain_any_line():  success"""
 528         run_env = self.run_env
 529
 530         script = lstrip("""
 531         import TestCommon
 532         test = TestCommon.TestCommon(workdir='')
 533
 534         lines = [
 535             'aaa\\n',
 536             'yyy\\n',
 537         ]
 538
 539         output = '''\\
 540         www
 541         xxx
 542         yyy
 543         zzz
 544         '''
 545
 546         test.must_contain_any_line(output, lines)
 547
 548         test.must_contain_any_line(output, ['www\\n'])
 549
 550         test.pass_test()
 551         """)
 552
 553         run_env.run(program=sys.executable, stdin=script)
 554         stdout = run_env.stdout()
 555         assert stdout == "", stdout
 556         stderr = run_env.stderr()
 557         assert stderr == "PASSED\n", stderr
 558
 559     def test_failure(self) -> None:
 560         """Test must_contain_any_line():  failure"""
 561         run_env = self.run_env
 562
 563         script = lstrip("""
 564         import TestCommon
 565         test = TestCommon.TestCommon(workdir='')
 566
 567         lines = [
 568             'xxx\\n',
 569             'yyy\\n',
 570         ]
 571
 572         output = '''\\
 573         www
 574         zzz
 575         '''
 576
 577         test.must_contain_any_line(output, lines)
 578
 579         test.pass_test()
 580         """)
 581
 582         expect = lstrip("""\
 583         Missing any expected line from output:
 584             'xxx%(expected_newline)s'
 585             'yyy%(expected_newline)s'
 586         output =========================================================================
 587         www
 588         zzz
 589         """ % globals())
 590
 591         run_env.run(program=sys.executable, stdin=script)
 592         stdout = run_env.stdout()
 593         stderr = run_env.stderr()
 594         assert stdout == expect, assert_display(expect, stdout, stderr)
 595         assert stderr.find("FAILED") != -1, stderr
 596
 597     def test_find(self) -> None:
 598         """Test must_contain_any_line():  find"""
 599         run_env = self.run_env
 600
 601         script = lstrip("""
 602         import re
 603         import TestCommon
 604         test = TestCommon.TestCommon(workdir='')
 605
 606         lines = [
 607             'aaa',
 608             '.*y',
 609         ]
 610
 611         output = '''\\
 612         www
 613         xxx
 614         yyy
 615         zzz
 616         '''
 617
 618         def re_search(output, line):
 619             return re.compile(line, re.S).search(output)
 620         test.must_contain_any_line(output, lines, find=re_search)
 621
 622         test.pass_test()
 623         """)
 624
 625         run_env.run(program=sys.executable, stdin=script)
 626         stdout = run_env.stdout()
 627         assert stdout == "", stdout
 628         stderr = run_env.stderr()
 629         assert stderr == "PASSED\n", stderr
 630
 631     def test_title(self) -> None:
 632         """Test must_contain_any_line():  title"""
 633         run_env = self.run_env
 634
 635         script = lstrip("""
 636         import TestCommon
 637         test = TestCommon.TestCommon(workdir='')
 638
 639         lines = [
 640             'xxx\\n',
 641             'yyy\\n',
 642         ]
 643
 644         output = '''\\
 645         www
 646         zzz
 647         '''
 648
 649         test.must_contain_any_line(output, lines, title='STDOUT')
 650
 651         test.pass_test()
 652         """)
 653
 654         expect = lstrip("""\
 655         Missing any expected line from STDOUT:
 656             'xxx%(expected_newline)s'
 657             'yyy%(expected_newline)s'
 658         STDOUT =========================================================================
 659         www
 660         zzz
 661         """ % globals())
 662
 663         run_env.run(program=sys.executable, stdin=script)
 664         stdout = run_env.stdout()
 665         stderr = run_env.stderr()
 666         assert stdout == expect, assert_display(expect, stdout, stderr)
 667         assert stderr.find("FAILED") != -1, stderr
 668
 669
 670
 671 class must_contain_exactly_lines_TestCase(TestCommonTestCase):
 672     def test_success_list(self) -> None:
 673         """Test must_contain_exactly_lines():  success (input list)"""
 674         run_env = self.run_env
 675
 676         script = lstrip("""
 677         import TestCommon
 678         test = TestCommon.TestCommon(workdir='')
 679
 680         lines = [
 681             'yyy\\n',
 682             'xxx\\n',
 683             'zzz',
 684             'www\\n',
 685         ]
 686
 687         output = '''\\
 688         www
 689         xxx
 690         yyy
 691         zzz
 692         '''
 693
 694         test.must_contain_exactly_lines(output, lines)
 695
 696         test.pass_test()
 697         """)
 698
 699         run_env.run(program=sys.executable, stdin=script)
 700         stdout = run_env.stdout()
 701         assert stdout == "", stdout
 702         stderr = run_env.stderr()
 703         assert stderr == "PASSED\n", stderr
 704
 705     def test_success_string(self) -> None:
 706         """Test must_contain_exactly_lines():  success (input string)"""
 707         run_env = self.run_env
 708
 709         script = lstrip("""
 710         import TestCommon
 711         test = TestCommon.TestCommon(workdir='')
 712
 713         lines = '''\\
 714         yyy
 715         xxx
 716         zzz
 717         www
 718         '''
 719
 720         output = '''\\
 721         www
 722         xxx
 723         yyy
 724         zzz
 725         '''
 726
 727         test.must_contain_exactly_lines(output, lines)
 728
 729         test.pass_test()
 730         """)
 731
 732         run_env.run(program=sys.executable, stdin=script)
 733         stdout = run_env.stdout()
 734         assert stdout == "", stdout
 735         stderr = run_env.stderr()
 736         assert stderr == "PASSED\n", stderr
 737
 738     def test_failure(self) -> None:
 739         """Test must_contain_exactly_lines():  failure"""
 740         run_env = self.run_env
 741
 742         script = lstrip("""
 743         import TestCommon
 744         test = TestCommon.TestCommon(workdir='')
 745
 746         lines = [
 747             'xxx\\n',
 748             'yyy\\n',
 749         ]
 750
 751         output = '''\\
 752         www
 753         zzz
 754         '''
 755
 756         test.must_contain_exactly_lines(output, lines)
 757
 758         test.pass_test()
 759         """)
 760
 761         expect = lstrip("""\
 762         Missing expected lines from output:
 763             'xxx'
 764             'yyy'
 765         Missing output =================================================================
 766         Extra unexpected lines from output:
 767             'www'
 768             'zzz'
 769         Extra output ===================================================================
 770         """)
 771
 772         run_env.run(program=sys.executable, stdin=script)
 773         stdout = run_env.stdout()
 774         stderr = run_env.stderr()
 775         assert stdout == expect, assert_display(expect, stdout, stderr)
 776         assert stderr.find("FAILED") != -1, stderr
 777
 778     def test_find(self) -> None:
 779         """Test must_contain_exactly_lines():  find"""
 780         run_env = self.run_env
 781
 782         script = lstrip("""
 783         import re
 784         import TestCommon
 785         test = TestCommon.TestCommon(workdir='')
 786
 787         lines = [
 788             'zzz',
 789             '.*y',
 790             'xxx',
 791             'www',
 792         ]
 793
 794         output = '''\\\
 795         www
 796         xxx
 797         yyy
 798         zzz
 799         '''
 800
 801         def re_search(output, line):
 802             pattern = re.compile(line, re.S)
 803             index = 0
 804             for o in output:
 805                 if pattern.search(o):
 806                     return index
 807                 index +=1
 808             return None
 809         test.must_contain_exactly_lines(output, lines, find=re_search)
 810
 811         test.pass_test()
 812         """)
 813
 814         run_env.run(program=sys.executable, stdin=script)
 815         stdout = run_env.stdout()
 816         assert stdout == "", stdout
 817         stderr = run_env.stderr()
 818         # Somehow, this fails on Py 3.12+ with:
 819         # AssertionError: <stdin>:13: SyntaxWarning: invalid escape sequence '\ '
 820         # assert stderr == "PASSED\n", stderr
 821         # So, just look for a substring:
 822         self.assertIn("PASSED", stderr)
 823
 824     def test_title(self) -> None:
 825         """Test must_contain_exactly_lines():  title"""
 826         run_env = self.run_env
 827
 828         script = lstrip("""
 829         import TestCommon
 830         test = TestCommon.TestCommon(workdir='')
 831
 832         lines = [
 833             'xxx\\n',
 834             'yyy\\n',
 835         ]
 836
 837         output = '''\\
 838         www
 839         zzz
 840         '''
 841
 842         test.must_contain_exactly_lines(output, lines, title='STDOUT')
 843
 844         test.pass_test()
 845         """)
 846
 847         expect = lstrip("""\
 848         Missing expected lines from STDOUT:
 849             'xxx'
 850             'yyy'
 851         Missing STDOUT =================================================================
 852         Extra unexpected lines from STDOUT:
 853             'www'
 854             'zzz'
 855         Extra STDOUT ===================================================================
 856         """)
 857
 858         run_env.run(program=sys.executable, stdin=script)
 859         stdout = run_env.stdout()
 860         stderr = run_env.stderr()
 861         assert stdout == expect, assert_display(expect, stdout, stderr)
 862         assert stderr.find("FAILED") != -1, stderr
 863
 864
 865
 866 class must_contain_lines_TestCase(TestCommonTestCase):
 867     def test_success(self) -> None:
 868         """Test must_contain_lines():  success"""
 869         run_env = self.run_env
 870
 871         script = lstrip("""
 872         import TestCommon
 873         test = TestCommon.TestCommon(workdir='')
 874
 875         lines = [
 876             'xxx\\n',
 877             'yyy\\n',
 878         ]
 879
 880         output = '''\\
 881         www
 882         xxx
 883         yyy
 884         zzz
 885         '''
 886
 887         test.must_contain_lines(lines, output)
 888
 889         test.pass_test()
 890         """)
 891
 892         run_env.run(program=sys.executable, stdin=script)
 893         stdout = run_env.stdout()
 894         assert stdout == "", stdout
 895         stderr = run_env.stderr()
 896         assert stderr == "PASSED\n", stderr
 897
 898     def test_failure(self) -> None:
 899         """Test must_contain_lines():  failure"""
 900         run_env = self.run_env
 901
 902         script = lstrip("""
 903         import TestCommon
 904         test = TestCommon.TestCommon(workdir='')
 905
 906         lines = [
 907             'xxx\\n',
 908             'yyy\\n',
 909         ]
 910
 911         output = '''\\
 912         www
 913         zzz
 914         '''
 915
 916         test.must_contain_lines(lines, output)
 917
 918         test.pass_test()
 919         """)
 920
 921         expect = lstrip("""\
 922         Missing expected lines from output:
 923             'xxx%(expected_newline)s'
 924             'yyy%(expected_newline)s'
 925         output =========================================================================
 926         www
 927         zzz
 928         """ % globals())
 929
 930         run_env.run(program=sys.executable, stdin=script)
 931         stdout = run_env.stdout()
 932         stderr = run_env.stderr()
 933         assert stdout == expect, assert_display(expect, stdout, stderr)
 934         assert stderr.find("FAILED") != -1, stderr
 935
 936
 937
 938 class must_exist_TestCase(TestCommonTestCase):
 939     def test_success(self) -> None:
 940         """Test must_exist():  success"""
 941         run_env = self.run_env
 942
 943         script = lstrip("""\
 944         from TestCommon import TestCommon
 945         tc = TestCommon(workdir='')
 946         tc.write('file1', "file1\\n")
 947         tc.must_exist('file1')
 948         tc.pass_test()
 949         """)
 950         run_env.run(program=sys.executable, stdin=script)
 951         stdout = run_env.stdout()
 952         assert stdout == "", stdout
 953         stderr = run_env.stderr()
 954         assert stderr == "PASSED\n", stderr
 955
 956     def test_failure(self) -> None:
 957         """Test must_exist():  failure"""
 958         run_env = self.run_env
 959
 960         script = lstrip("""\
 961         from TestCommon import TestCommon
 962         tc = TestCommon(workdir='')
 963         tc.must_exist('file1')
 964         tc.pass_test()
 965         """)
 966         run_env.run(program=sys.executable, stdin=script)
 967         stdout = run_env.stdout()
 968         assert stdout == "Missing files: `file1'\n", stdout
 969         stderr = run_env.stderr()
 970         assert stderr.find("FAILED") != -1, stderr
 971
 972     def test_failure_message(self) -> None:
 973         """Test must_exist():  failure with extra message"""
 974         run_env = self.run_env
 975
 976         script = lstrip("""\
 977         from TestCommon import TestCommon
 978         tc = TestCommon(workdir='')
 979         tc.must_exist('file1', message="Extra Info")
 980         tc.pass_test()
 981         """)
 982         run_env.run(program=sys.executable, stdin=script)
 983         stdout = run_env.stdout()
 984         assert stdout == "Missing files: `file1'\n", stdout
 985         stderr = run_env.stderr()
 986         assert stderr.find("Extra Info") != -1, stderr
 987
 988     def test_file_specified_as_list(self) -> None:
 989         """Test must_exist():  file specified as list"""
 990         run_env = self.run_env
 991
 992         script = lstrip("""\
 993         from TestCommon import TestCommon
 994         tc = TestCommon(workdir='')
 995         tc.subdir('sub')
 996         tc.write(['sub', 'file1'], "sub/file1\\n")
 997         tc.must_exist(['sub', 'file1'])
 998         tc.pass_test()
 999         """)
1000         run_env.run(program=sys.executable, stdin=script)
1001         stdout = run_env.stdout()
1002         assert stdout == "", stdout
1003         stderr = run_env.stderr()
1004         assert stderr == "PASSED\n", stderr
1005
1006     @unittest.skipIf(sys.platform == 'win32', "Skip symlink test on win32")
1007     def test_broken_link(self) -> None :
1008         """Test must_exist():  exists but it is a broken link"""
1009         run_env = self.run_env
1010
1011         script = lstrip("""\
1012         from TestCommon import TestCommon
1013         tc = TestCommon(workdir='')
1014         tc.symlink('badtarget', "brokenlink")
1015         tc.must_exist('brokenlink')
1016         tc.pass_test()
1017         """)
1018         run_env.run(program=sys.executable, stdin=script)
1019         stdout = run_env.stdout()
1020         assert stdout == "", stdout
1021         stderr = run_env.stderr()
1022         assert stderr == "PASSED\n", stderr
1023
1024 class must_exist_one_of_TestCase(TestCommonTestCase):
1025     def test_success(self) -> None:
1026         """Test must_exist_one_of():  success"""
1027         run_env = self.run_env
1028
1029         script = lstrip("""\
1030         from TestCommon import TestCommon
1031         tc = TestCommon(workdir='')
1032         tc.write('file1', "file1\\n")
1033         tc.must_exist_one_of(['file1'])
1034         tc.pass_test()
1035         """)
1036         run_env.run(program=sys.executable, stdin=script)
1037         stdout = run_env.stdout()
1038         assert stdout == "", stdout
1039         stderr = run_env.stderr()
1040         assert stderr == "PASSED\n", stderr
1041
1042     def test_failure(self) -> None:
1043         """Test must_exist_one_of():  failure"""
1044         run_env = self.run_env
1045
1046         script = lstrip("""\
1047         from TestCommon import TestCommon
1048         tc = TestCommon(workdir='')
1049         tc.must_exist_one_of(['file1'])
1050         tc.pass_test()
1051         """)
1052         run_env.run(program=sys.executable, stdin=script)
1053         stdout = run_env.stdout()
1054         assert stdout == "Missing one of: `file1'\n", stdout
1055         stderr = run_env.stderr()
1056         assert stderr.find("FAILED") != -1, stderr
1057
1058     def test_failure_message(self) -> None:
1059         """Test must_exist_one_of():  failure with extra message"""
1060         run_env = self.run_env
1061
1062         script = lstrip("""\
1063         from TestCommon import TestCommon
1064         tc = TestCommon(workdir='')
1065         tc.must_exist_one_of(['file1'], message="Extra Info")
1066         tc.pass_test()
1067         """)
1068         run_env.run(program=sys.executable, stdin=script)
1069         stdout = run_env.stdout()
1070         assert stdout == "Missing one of: `file1'\n", stdout
1071         stderr = run_env.stderr()
1072         assert stderr.find("Extra Info") != -1, stderr
1073
1074     def test_files_specified_as_list(self) -> None:
1075         """Test must_exist_one_of():  files specified as list"""
1076         run_env = self.run_env
1077
1078         script = lstrip("""\
1079         from TestCommon import TestCommon
1080         tc = TestCommon(workdir='')
1081         tc.write('file1', "file1\\n")
1082         tc.must_exist_one_of(['file2', 'file1'])
1083         tc.pass_test()
1084         """)
1085         run_env.run(program=sys.executable, stdin=script)
1086         stdout = run_env.stdout()
1087         assert stdout == "", stdout
1088         stderr = run_env.stderr()
1089         assert stderr == "PASSED\n", stderr
1090
1091     def test_files_specified_with_wildcards(self) -> None:
1092         """Test must_exist_one_of():  files specified with wildcards"""
1093         run_env = self.run_env
1094
1095         script = lstrip("""\
1096         from TestCommon import TestCommon
1097         tc = TestCommon(workdir='')
1098         tc.write('file7', "file7\\n")
1099         tc.must_exist_one_of(['file?'])
1100         tc.pass_test()
1101         """)
1102         run_env.run(program=sys.executable, stdin=script)
1103         stdout = run_env.stdout()
1104         assert stdout == "", stdout
1105         stderr = run_env.stderr()
1106         assert stderr == "PASSED\n", stderr
1107
1108     def test_file_given_as_list(self) -> None:
1109         """Test must_exist_one_of():  file given as list"""
1110         run_env = self.run_env
1111
1112         script = lstrip("""\
1113         from TestCommon import TestCommon
1114         tc = TestCommon(workdir='')
1115         tc.subdir('sub')
1116         tc.write(['sub', 'file1'], "sub/file1\\n")
1117         tc.must_exist_one_of(['file2', ['sub', 'file1']])
1118         tc.pass_test()
1119         """)
1120         run_env.run(program=sys.executable, stdin=script)
1121         stdout = run_env.stdout()
1122         assert stdout == "", stdout
1123         stderr = run_env.stderr()
1124         assert stderr == "PASSED\n", stderr
1125
1126     def test_file_given_as_sequence(self) -> None:
1127         """Test must_exist_one_of():  file given as sequence"""
1128         run_env = self.run_env
1129
1130         script = lstrip("""\
1131         from TestCommon import TestCommon
1132         tc = TestCommon(workdir='')
1133         tc.subdir('sub')
1134         tc.write(['sub', 'file1'], "sub/file1\\n")
1135         tc.must_exist_one_of(['file2', ('sub', 'file1')])
1136         tc.pass_test()
1137         """)
1138         run_env.run(program=sys.executable, stdin=script)
1139         stdout = run_env.stdout()
1140         assert stdout == "", stdout
1141         stderr = run_env.stderr()
1142         assert stderr == "PASSED\n", stderr
1143
1144 class must_match_TestCase(TestCommonTestCase):
1145     def test_success(self) -> None:
1146         """Test must_match():  success"""
1147         run_env = self.run_env
1148
1149         script = lstrip("""\
1150         from TestCommon import TestCommon
1151         tc = TestCommon(workdir='')
1152         tc.write('file1', "file1\\n")
1153         tc.must_match('file1', "file1\\n")
1154         tc.pass_test()
1155         """)
1156         run_env.run(program=sys.executable, stdin=script)
1157         stdout = run_env.stdout()
1158         assert stdout == "", stdout
1159         stderr = run_env.stderr()
1160         assert stderr == "PASSED\n", stderr
1161
1162     def test_file_does_not_exists(self) -> None:
1163         """Test must_match():  file does not exist"""
1164         run_env = self.run_env
1165
1166         script = lstrip("""\
1167         from TestCommon import TestCommon
1168         tc = TestCommon(workdir='')
1169         tc.must_match('file1', "file1\\n")
1170         tc.pass_test()
1171         """)
1172         run_env.run(program=sys.executable, stdin=script)
1173         stdout = run_env.stdout()
1174         assert stdout == "", stdout
1175         stderr = run_env.stderr()
1176         assert stderr.find("No such file or directory:") != -1, stderr
1177
1178     def test_failure(self) -> None:
1179         """Test must_match():  failure"""
1180         run_env = self.run_env
1181
1182         script = lstrip("""\
1183         from TestCommon import TestCommon
1184         tc = TestCommon(workdir='')
1185         tc.write('file1', "file1 does not match\\n")
1186         tc.must_match('file1', "file1\\n")
1187         tc.run()
1188         """)
1189
1190         expect = lstrip("""\
1191         match_re: mismatch at line 0:
1192           search re='^file1$'
1193           line='file1 does not match'
1194         Unexpected contents of `file1'
1195         contents =======================================================================
1196         1c1
1197         < file1
1198         ---
1199         > file1 does not match
1200         """)
1201         run_env.run(program=sys.executable, stdin=script)
1202         stdout = run_env.stdout()
1203         assert stdout == expect, stdout
1204         stderr = run_env.stderr()
1205         assert stderr.find("FAILED") != -1, stderr
1206
1207     def test_mode(self) -> None:
1208         """Test must_match():  mode"""
1209         run_env = self.run_env
1210
1211         script = lstrip("""\
1212         from TestCommon import TestCommon
1213         tc = TestCommon(workdir='')
1214         tc.write('file1', "file1\\n", mode='w')
1215         tc.must_match('file1', "file1\\n", mode='r')
1216         tc.write('file2', "file2\\n", mode='wb')
1217         tc.must_match('file2', "file2\\n", mode='rb')
1218         tc.pass_test()
1219         """)
1220         run_env.run(program=sys.executable, stdin=script)
1221         stdout = run_env.stdout()
1222         assert stdout == "", stdout
1223         stderr = run_env.stderr()
1224         assert stderr == "PASSED\n", stderr
1225
1226
1227
1228 class must_not_be_writable_TestCase(TestCommonTestCase):
1229     def test_file_does_not_exists(self) -> None:
1230         """Test must_not_be_writable():  file does not exist"""
1231         run_env = self.run_env
1232
1233         script = lstrip("""\
1234         from TestCommon import TestCommon
1235         tc = TestCommon(workdir='')
1236         tc.must_not_be_writable('file1')
1237         tc.pass_test()
1238         """)
1239         run_env.run(program=sys.executable, stdin=script)
1240         stdout = run_env.stdout()
1241         assert stdout == "Missing files: `file1'\n", stdout
1242         stderr = run_env.stderr()
1243         assert stderr.find("FAILED") != -1, stderr
1244
1245     def test_writable_file_exists(self) -> None:
1246         """Test must_not_be_writable():  writable file exists"""
1247         run_env = self.run_env
1248
1249         script = lstrip("""\
1250         import os
1251         import stat
1252         from TestCommon import TestCommon
1253         tc = TestCommon(workdir='')
1254         tc.write('file1', "file1\\n")
1255         f1 = tc.workpath('file1')
1256         mode = os.stat(f1).st_mode
1257         os.chmod(f1, mode | stat.S_IWUSR)
1258         tc.must_not_be_writable('file1')
1259         tc.pass_test()
1260         """)
1261         run_env.run(program=sys.executable, stdin=script)
1262         stdout = run_env.stdout()
1263         assert stdout == "Writable files: `file1'\n", stdout
1264         stderr = run_env.stderr()
1265         assert stderr.find("FAILED") != -1, stderr
1266
1267     def test_non_writable_file_exists(self) -> None:
1268         """Test must_not_be_writable():  non-writable file exists"""
1269         run_env = self.run_env
1270
1271         script = lstrip("""\
1272         import os
1273         import stat
1274         from TestCommon import TestCommon
1275         tc = TestCommon(workdir='')
1276         tc.write('file1', "file1\\n")
1277         f1 = tc.workpath('file1')
1278         mode = os.stat(f1).st_mode
1279         os.chmod(f1, mode & ~stat.S_IWUSR)
1280         tc.must_not_be_writable('file1')
1281         tc.pass_test()
1282         """)
1283         run_env.run(program=sys.executable, stdin=script)
1284         stdout = run_env.stdout()
1285         assert stdout == "", stdout
1286         stderr = run_env.stderr()
1287         assert stderr == "PASSED\n", stderr
1288
1289     def test_file_specified_as_list(self) -> None:
1290         """Test must_not_be_writable():  file specified as list"""
1291         run_env = self.run_env
1292
1293         script = lstrip("""\
1294         import os
1295         import stat
1296         from TestCommon import TestCommon
1297         tc = TestCommon(workdir='')
1298         tc.subdir('sub')
1299         tc.write(['sub', 'file1'], "sub/file1\\n")
1300         f1 = tc.workpath('sub', 'file1')
1301         mode = os.stat(f1).st_mode
1302         os.chmod(f1, mode & ~stat.S_IWUSR)
1303         tc.must_not_be_writable(['sub', 'file1'])
1304         tc.pass_test()
1305         """)
1306         run_env.run(program=sys.executable, stdin=script)
1307         stdout = run_env.stdout()
1308         assert stdout == "", stdout
1309         stderr = run_env.stderr()
1310         assert stderr == "PASSED\n", stderr
1311
1312
1313
1314 class must_not_contain_TestCase(TestCommonTestCase):
1315     def test_success(self) -> None:
1316         """Test must_not_contain():  success"""
1317         run_env = self.run_env
1318
1319         script = lstrip("""\
1320         from TestCommon import TestCommon
1321         tc = TestCommon(workdir='')
1322         tc.write('file1', "file1 contents\\n")
1323         tc.must_not_contain('file1', b"1 does not contain c")
1324         tc.pass_test()
1325         """)
1326         run_env.run(program=sys.executable, stdin=script)
1327         stdout = run_env.stdout()
1328         assert stdout == "", stdout
1329         stderr = run_env.stderr()
1330         assert stderr == "PASSED\n", stderr
1331
1332     def test_file_does_not_exist(self) -> None:
1333         """Test must_not_contain():  file does not exist"""
1334         run_env = self.run_env
1335
1336         script = lstrip("""\
1337         from TestCommon import TestCommon
1338         tc = TestCommon(workdir='')
1339         tc.must_not_contain('file1', "1 c\\n")
1340         tc.pass_test()
1341         """)
1342         run_env.run(program=sys.executable, stdin=script)
1343         stdout = run_env.stdout()
1344         assert stdout == "", stdout
1345         stderr = run_env.stderr()
1346         assert stderr.find("No such file or directory:") != -1, stderr
1347
1348     def test_failure(self) -> None:
1349         """Test must_not_contain():  failure"""
1350         run_env = self.run_env
1351
1352         script = lstrip("""\
1353         from TestCommon import TestCommon
1354         tc = TestCommon(workdir='')
1355         tc.write('file1', "file1 does contain contents\\n")
1356         tc.must_not_contain('file1', b"1 does contain c")
1357         tc.run()
1358         """)
1359         expect = lstrip("""\
1360         File `file1' contains banned string.
1361         Banned string ==================================================================
1362         b'1 does contain c'
1363         file1 contents =================================================================
1364         b'file1 does contain contents\\n'
1365         """)
1366         run_env.run(program=sys.executable, stdin=script)
1367         stdout = run_env.stdout()
1368         assert stdout == expect, f"\ngot:\n{stdout}\nexpected:\n{expect}"
1369
1370         stderr = run_env.stderr()
1371         assert stderr.find("FAILED") != -1, stderr
1372
1373     def test_failure_index_0(self) -> None:
1374         """Test must_not_contain():  failure at index 0"""
1375         run_env = self.run_env
1376
1377         script = lstrip("""\
1378         from TestCommon import TestCommon
1379         tc = TestCommon(workdir='')
1380         tc.write('file1', "file1 does contain contents\\n")
1381         tc.must_not_contain('file1', b"file1 does")
1382         tc.run()
1383         """)
1384         expect = lstrip("""\
1385         File `file1' contains banned string.
1386         Banned string ==================================================================
1387         b'file1 does'
1388         file1 contents =================================================================
1389         b'file1 does contain contents\\n'
1390         """)
1391         run_env.run(program=sys.executable, stdin=script)
1392         stdout = run_env.stdout()
1393         assert stdout == expect, f"\ngot:\n{stdout}\nexpected:\n{expect}"
1394
1395         stderr = run_env.stderr()
1396         assert stderr.find("FAILED") != -1, stderr
1397
1398     def test_mode(self) -> None:
1399         """Test must_not_contain():  mode"""
1400         run_env = self.run_env
1401
1402         script = lstrip("""\
1403         from TestCommon import TestCommon
1404         tc = TestCommon(workdir='')
1405         tc.write('file1', "file1 contents\\n", mode='w')
1406         tc.must_not_contain('file1', "1 does not contain c", mode='r')
1407         tc.write('file2', "file2 contents\\n", mode='wb')
1408         tc.must_not_contain('file2', b"2 does not contain c", mode='rb')
1409         tc.pass_test()
1410         """)
1411         run_env.run(program=sys.executable, stdin=script)
1412         stdout = run_env.stdout()
1413         assert stdout == "", stdout
1414         stderr = run_env.stderr()
1415         assert stderr == "PASSED\n", stderr
1416
1417
1418
1419 class must_not_contain_any_line_TestCase(TestCommonTestCase):
1420     def test_failure(self) -> None:
1421         """Test must_not_contain_any_line():  failure"""
1422         run_env = self.run_env
1423
1424         script = lstrip("""
1425         import TestCommon
1426         test = TestCommon.TestCommon(workdir='')
1427
1428         lines = [
1429             'xxx\\n',
1430             'yyy\\n',
1431             'www\\n',
1432         ]
1433
1434         output = '''\\
1435         www
1436         xxx
1437         yyy
1438         zzz
1439         '''
1440
1441         test.must_not_contain_any_line(output, lines)
1442
1443         test.pass_test()
1444         """)
1445
1446         expect = lstrip("""\
1447         Unexpected lines in output:
1448             'xxx%(expected_newline)s'
1449             'yyy%(expected_newline)s'
1450             'www%(expected_newline)s'
1451         output =========================================================================
1452         www
1453         xxx
1454         yyy
1455         zzz
1456         """ % globals())
1457
1458         run_env.run(program=sys.executable, stdin=script)
1459         stdout = run_env.stdout()
1460         stderr = run_env.stderr()
1461         assert stdout == expect, assert_display(expect, stdout, stderr)
1462         assert stderr.find("FAILED") != -1, stderr
1463
1464     def test_find(self) -> None:
1465         """Test must_not_contain_any_line():  find"""
1466         run_env = self.run_env
1467
1468         script = lstrip("""
1469         import re
1470         import TestCommon
1471         test = TestCommon.TestCommon(workdir='')
1472
1473         lines = [
1474             'x.*'
1475             '.*y'
1476         ]
1477
1478         output = '''\\
1479         www
1480         zzz
1481         '''
1482
1483         def re_search(output, line):
1484             return re.compile(line, re.S).search(output)
1485         test.must_not_contain_any_line(output, lines, find=re_search)
1486
1487         test.pass_test()
1488         """)
1489
1490         run_env.run(program=sys.executable, stdin=script)
1491         stdout = run_env.stdout()
1492         assert stdout == "", stdout
1493         stderr = run_env.stderr()
1494         assert stderr == "PASSED\n", stderr
1495
1496     def test_success(self) -> None:
1497         """Test must_not_contain_any_line():  success"""
1498         run_env = self.run_env
1499
1500         script = lstrip("""
1501         import TestCommon
1502         test = TestCommon.TestCommon(workdir='')
1503
1504         lines = [
1505             'xxx\\n'
1506             'yyy\\n'
1507         ]
1508
1509         output = '''\\
1510         www
1511         zzz
1512         '''
1513
1514         test.must_not_contain_any_line(output, lines)
1515
1516         test.pass_test()
1517         """)
1518
1519         run_env.run(program=sys.executable, stdin=script)
1520         stdout = run_env.stdout()
1521         assert stdout == "", stdout
1522         stderr = run_env.stderr()
1523         assert stderr == "PASSED\n", stderr
1524
1525     def test_title(self) -> None:
1526         """Test must_not_contain_any_line():  title"""
1527         run_env = self.run_env
1528
1529         script = lstrip("""
1530         import TestCommon
1531         test = TestCommon.TestCommon(workdir='')
1532
1533         lines = [
1534             'xxx\\n',
1535             'yyy\\n',
1536         ]
1537
1538         output = '''\\
1539         www
1540         xxx
1541         yyy
1542         zzz
1543         '''
1544
1545         test.must_not_contain_any_line(output, lines, title='XYZZY')
1546
1547         test.pass_test()
1548         """)
1549
1550         expect = lstrip("""\
1551         Unexpected lines in XYZZY:
1552             'xxx%(expected_newline)s'
1553             'yyy%(expected_newline)s'
1554         XYZZY ==========================================================================
1555         www
1556         xxx
1557         yyy
1558         zzz
1559         """ % globals())
1560
1561         run_env.run(program=sys.executable, stdin=script)
1562         stdout = run_env.stdout()
1563         stderr = run_env.stderr()
1564         assert stdout == expect, assert_display(expect, stdout, stderr)
1565         assert stderr.find("FAILED") != -1, stderr
1566
1567
1568
1569 class must_not_contain_lines_TestCase(TestCommonTestCase):
1570     def test_failure(self) -> None:
1571         """Test must_not_contain_lines():  failure"""
1572         run_env = self.run_env
1573
1574         script = lstrip("""
1575         import TestCommon
1576         test = TestCommon.TestCommon(workdir='')
1577
1578         lines = [
1579             'xxx\\n',
1580             'yyy\\n',
1581         ]
1582
1583         output = '''\\
1584         www
1585         xxx
1586         yyy
1587         zzz
1588         '''
1589
1590         test.must_not_contain_lines(lines, output)
1591
1592         test.pass_test()
1593         """)
1594
1595         expect = lstrip("""\
1596         Unexpected lines in output:
1597             'xxx%(expected_newline)s'
1598             'yyy%(expected_newline)s'
1599         output =========================================================================
1600         www
1601         xxx
1602         yyy
1603         zzz
1604         """ % globals())
1605
1606         run_env.run(program=sys.executable, stdin=script)
1607         stdout = run_env.stdout()
1608         stderr = run_env.stderr()
1609         assert stdout == expect, assert_display(expect, stdout, stderr)
1610         assert stderr.find("FAILED") != -1, stderr
1611
1612     def test_success(self) -> None:
1613         """Test must_not_contain_lines():  success"""
1614         run_env = self.run_env
1615
1616         script = lstrip("""
1617         import TestCommon
1618         test = TestCommon.TestCommon(workdir='')
1619
1620         lines = [
1621             'xxx\\n'
1622             'yyy\\n'
1623         ]
1624
1625         output = '''\\
1626         www
1627         zzz
1628         '''
1629
1630         test.must_not_contain_lines(lines, output)
1631
1632         test.pass_test()
1633         """)
1634
1635         run_env.run(program=sys.executable, stdin=script)
1636         stdout = run_env.stdout()
1637         assert stdout == "", stdout
1638         stderr = run_env.stderr()
1639         assert stderr == "PASSED\n", stderr
1640
1641
1642
1643 class must_not_exist_TestCase(TestCommonTestCase):
1644     def test_failure(self) -> None:
1645         """Test must_not_exist():  failure"""
1646         run_env = self.run_env
1647
1648         script = lstrip("""\
1649         from TestCommon import TestCommon
1650         tc = TestCommon(workdir='')
1651         tc.write('file1', "file1\\n")
1652         tc.must_not_exist('file1')
1653         tc.pass_test()
1654         """)
1655         run_env.run(program=sys.executable, stdin=script)
1656         stdout = run_env.stdout()
1657         assert stdout == "Unexpected files exist: `file1'\n", stdout
1658         stderr = run_env.stderr()
1659         assert stderr.find("FAILED") != -1, stderr
1660
1661     def test_success(self) -> None:
1662         """Test must_not_exist():  success"""
1663         run_env = self.run_env
1664
1665         script = lstrip("""\
1666         from TestCommon import TestCommon
1667         tc = TestCommon(workdir='')
1668         tc.must_not_exist('file1')
1669         tc.pass_test()
1670         """)
1671         run_env.run(program=sys.executable, stdin=script)
1672         stdout = run_env.stdout()
1673         assert stdout == "", stdout
1674         stderr = run_env.stderr()
1675         assert stderr == "PASSED\n", stderr
1676
1677     def test_file_specified_as_list(self) -> None:
1678         """Test must_not_exist():  file specified as list"""
1679         run_env = self.run_env
1680
1681         script = lstrip("""\
1682         from TestCommon import TestCommon
1683         tc = TestCommon(workdir='')
1684         tc.subdir('sub')
1685         tc.must_not_exist(['sub', 'file1'])
1686         tc.pass_test()
1687         """)
1688         run_env.run(program=sys.executable, stdin=script)
1689         stdout = run_env.stdout()
1690         assert stdout == "", stdout
1691         stderr = run_env.stderr()
1692         assert stderr == "PASSED\n", stderr
1693
1694     @unittest.skipIf(sys.platform == 'win32', "Skip symlink test on win32")
1695     def test_existing_broken_link(self) -> None:
1696         """Test must_not_exist():  exists but it is a broken link"""
1697         run_env = self.run_env
1698
1699         script = lstrip("""\
1700         from TestCommon import TestCommon
1701         tc = TestCommon(workdir='')
1702         tc.symlink('badtarget', 'brokenlink')
1703         tc.must_not_exist('brokenlink')
1704         tc.pass_test()
1705         """)
1706         run_env.run(program=sys.executable, stdin=script)
1707         stdout = run_env.stdout()
1708         assert stdout == "Unexpected files exist: `brokenlink'\n", stdout
1709         stderr = run_env.stderr()
1710         assert stderr.find("FAILED") != -1, stderr
1711
1712 class must_not_exist_any_of_TestCase(TestCommonTestCase):
1713     def test_success(self) -> None:
1714         """Test must_not_exist_any_of():  success"""
1715         run_env = self.run_env
1716
1717         script = lstrip("""\
1718         from TestCommon import TestCommon
1719         tc = TestCommon(workdir='')
1720         tc.must_not_exist_any_of(['file1'])
1721         tc.pass_test()
1722         """)
1723         run_env.run(program=sys.executable, stdin=script)
1724         stdout = run_env.stdout()
1725         assert stdout == "", stdout
1726         stderr = run_env.stderr()
1727         assert stderr == "PASSED\n", stderr
1728
1729     def test_failure(self) -> None:
1730         """Test must_not_exist_any_of():  failure"""
1731         run_env = self.run_env
1732
1733         script = lstrip("""\
1734         from TestCommon import TestCommon
1735         tc = TestCommon(workdir='')
1736         tc.write('file1', "file1\\n")
1737         tc.must_not_exist_any_of(['file1'])
1738         tc.pass_test()
1739         """)
1740         run_env.run(program=sys.executable, stdin=script)
1741         stdout = run_env.stdout()
1742         assert stdout == "Unexpected files exist: `file1'\n", stdout
1743         stderr = run_env.stderr()
1744         assert stderr.find("FAILED") != -1, stderr
1745
1746     def test_files_specified_as_list(self) -> None:
1747         """Test must_not_exist_any_of():  files specified as list"""
1748         run_env = self.run_env
1749
1750         script = lstrip("""\
1751         from TestCommon import TestCommon
1752         tc = TestCommon(workdir='')
1753         tc.must_not_exist_any_of(['file2', 'file1'])
1754         tc.pass_test()
1755         """)
1756         run_env.run(program=sys.executable, stdin=script)
1757         stdout = run_env.stdout()
1758         assert stdout == "", stdout
1759         stderr = run_env.stderr()
1760         assert stderr == "PASSED\n", stderr
1761
1762     def test_files_specified_with_wildcards(self) -> None:
1763         """Test must_not_exist_any_of():  files specified with wildcards"""
1764         run_env = self.run_env
1765
1766         script = lstrip("""\
1767         from TestCommon import TestCommon
1768         tc = TestCommon(workdir='')
1769         tc.write('file7', "file7\\n")
1770         tc.must_not_exist_any_of(['files?'])
1771         tc.pass_test()
1772         """)
1773         run_env.run(program=sys.executable, stdin=script)
1774         stdout = run_env.stdout()
1775         assert stdout == "", stdout
1776         stderr = run_env.stderr()
1777         assert stderr == "PASSED\n", stderr
1778
1779     def test_file_given_as_list(self) -> None:
1780         """Test must_not_exist_any_of():  file given as list"""
1781         run_env = self.run_env
1782
1783         script = lstrip("""\
1784         from TestCommon import TestCommon
1785         tc = TestCommon(workdir='')
1786         tc.subdir('sub')
1787         tc.write(['sub', 'file1'], "sub/file1\\n")
1788         tc.must_not_exist_any_of(['file2',
1789                               ['sub', 'files*']])
1790         tc.pass_test()
1791         """)
1792         run_env.run(program=sys.executable, stdin=script)
1793         stdout = run_env.stdout()
1794         assert stdout == "", stdout
1795         stderr = run_env.stderr()
1796         assert stderr == "PASSED\n", stderr
1797
1798     def test_file_given_as_sequence(self) -> None:
1799         """Test must_not_exist_any_of():  file given as sequence"""
1800         run_env = self.run_env
1801
1802         script = lstrip("""\
1803         from TestCommon import TestCommon
1804         tc = TestCommon(workdir='')
1805         tc.subdir('sub')
1806         tc.write(['sub', 'file1'], "sub/file1\\n")
1807         tc.must_not_exist_any_of(['file2',
1808                               ('sub', 'files?')])
1809         tc.pass_test()
1810         """)
1811         run_env.run(program=sys.executable, stdin=script)
1812         stdout = run_env.stdout()
1813         assert stdout == "", stdout
1814         stderr = run_env.stderr()
1815         assert stderr == "PASSED\n", stderr
1816
1817 class must_not_be_empty_TestCase(TestCommonTestCase):
1818     def test_failure(self) -> None:
1819         """Test must_not_be_empty():  failure"""
1820         run_env = self.run_env
1821
1822         script = lstrip("""\
1823         from TestCommon import TestCommon
1824         tc = TestCommon(workdir='')
1825         tc.write('file1', "")
1826         tc.must_not_be_empty('file1')
1827         tc.pass_test()
1828         """)
1829         run_env.run(program=sys.executable, stdin=script)
1830         stdout = run_env.stdout()
1831         assert stdout == "File is empty: `file1'\n", stdout
1832         stderr = run_env.stderr()
1833         assert stderr.find("FAILED") != -1, stderr
1834
1835     def test_success(self) -> None:
1836         """Test must_not_be_empty():  success"""
1837         run_env = self.run_env
1838
1839         script = lstrip("""\
1840         from TestCommon import TestCommon
1841         tc = TestCommon(workdir='')
1842         tc.write('file1', "file1\\n")
1843         tc.must_not_be_empty('file1')
1844         tc.pass_test()
1845         """)
1846         run_env.run(program=sys.executable, stdin=script)
1847         stdout = run_env.stdout()
1848         assert stdout == "", stdout
1849         stderr = run_env.stderr()
1850         assert stderr == "PASSED\n", stderr
1851
1852     def test_file_doesnt_exist(self) -> None:
1853         """Test must_not_be_empty():  failure"""
1854         run_env = self.run_env
1855
1856         script = lstrip("""\
1857         from TestCommon import TestCommon
1858         tc = TestCommon(workdir='')
1859         tc.must_not_be_empty('file1')
1860         tc.pass_test()
1861         """)
1862         run_env.run(program=sys.executable, stdin=script)
1863         stdout = run_env.stdout()
1864         assert stdout == "File doesn't exist: `file1'\n", stdout
1865         stderr = run_env.stderr()
1866         assert stderr.find("FAILED") != -1, stderr
1867
1868 class run_TestCase(TestCommonTestCase):
1869     def test_argument_handling(self) -> None:
1870         """Test run():  argument handling"""
1871
1872         script = lstrip("""\
1873         from TestCommon import TestCommon, match_exact
1874         tc = TestCommon(program=r'%(pass_script)s',
1875                         interpreter=r'%(python)s',
1876                         workdir="",
1877                         match=match_exact)
1878         tc.run(arguments = "arg1 arg2 arg3",
1879                stdout = r"%(pass_script)s:  STDOUT:  ['arg1', 'arg2', 'arg3']" + "\\n")
1880         """)
1881
1882         self.run_execution_test(script, "", "")
1883
1884     def test_default_pass(self) -> None:
1885         """Test run():  default arguments, script passes"""
1886
1887         script = lstrip("""\
1888         from TestCommon import TestCommon
1889         tc = TestCommon(program=r'%(pass_script)s',
1890                         interpreter=r'%(python)s',
1891                         workdir='')
1892         tc.run()
1893         """)
1894
1895         self.run_execution_test(script, "", "")
1896
1897     def test_default_fail(self) -> None:
1898         """Test run():  default arguments, script fails"""
1899
1900         script = lstrip("""\
1901         from TestCommon import TestCommon
1902         tc = TestCommon(program=r'%(fail_script)s',
1903                         interpreter=r'%(python)s',
1904                         workdir='')
1905         tc.run()
1906         """)
1907
1908         expect_stdout = lstrip("""\
1909         %(fail_script)s returned 1
1910         STDOUT =========================================================================
1911         %(fail_script)s:  STDOUT:  []
1912
1913         STDERR =========================================================================
1914
1915         """)
1916
1917         expect_stderr = lstrip("""\
1918         FAILED test of .*fail
1919         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
1920         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
1921         \\tfrom line \\d+ of <stdin>( \\(<module>\\))?
1922         """)
1923         expect_stderr = re.compile(expect_stderr, re.M)
1924
1925         self.run_execution_test(script, expect_stdout, expect_stderr)
1926
1927     def test_default_stderr(self) -> None:
1928         """Test run():  default arguments, error output"""
1929         script = lstrip("""\
1930         from TestCommon import TestCommon
1931         tc = TestCommon(program=r'%(stderr_script)s',
1932                         interpreter=r'%(python)s',
1933                         workdir='')
1934         tc.run()
1935         """)
1936
1937         expect_stdout = lstrip("""\
1938         match_re: expected 1 lines, found 2
1939         STDOUT =========================================================================
1940
1941         STDERR =========================================================================
1942         0a1
1943         > %(stderr_script)s:  STDERR:  []
1944         """)
1945
1946         expect_stderr = lstrip("""\
1947         FAILED test of .*stderr
1948         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
1949         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
1950         \\tfrom line \\d+ of <stdin>
1951         """)
1952         expect_stderr = re.compile(expect_stderr, re.M)
1953
1954         self.run_execution_test(script, expect_stdout, expect_stderr)
1955
1956     def test_exception_handling(self) -> None:
1957         """Test run():  exception handling"""
1958         script = lstrip("""\
1959         import TestCmd
1960         from TestCommon import TestCommon
1961         def raise_exception(*args, **kw):
1962             raise TypeError("forced TypeError")
1963         TestCmd.TestCmd.start = raise_exception
1964         tc = TestCommon(program=r'%(pass_script)s',
1965                         interpreter=r'%(python)s',
1966                         workdir='')
1967         tc.run()
1968         """)
1969
1970         expect_stdout = lstrip("""\
1971         STDOUT =========================================================================
1972         None
1973         STDERR =========================================================================
1974         None
1975         """)
1976
1977         expect_stderr = lstrip(
1978             fr"""Exception trying to execute: \[{re.escape(repr(sys.executable))}, '[^']*pass'\]
1979 Traceback \(most recent call last\):
1980   File "<stdin>", line \d+, in (\?|<module>)
1981   File "[^"]+TestCommon\.py", line \d+, in run
1982     super\(\)\.run\(\*\*kw\)
1983   File "[^"]+TestCmd\.py", line \d+, in run
1984     p = self\.start\(program=program,
1985 (?:\s*\^*\s)?  File \"[^\"]+TestCommon\.py\", line \d+, in start
1986     raise e
1987   File "[^"]+TestCommon\.py", line \d+, in start
1988     return super\(\)\.start\(program, interpreter, arguments,
1989 (?:\s*\^*\s)?  File \"<stdin>\", line \d+, in raise_exception
1990 TypeError: forced TypeError
1991 """)
1992
1993         # Python 3.13+ expanded error msgs again, not in a way we can easily
1994         # accomodate with the other regex.
1995         expect_enhanced_stderr = lstrip(
1996             fr"""Exception trying to execute: \[{re.escape(repr(sys.executable))}, '[^']*pass'\]
1997 Traceback \(most recent call last\):
1998   File "<stdin>", line \d+, in (\?|<module>)
1999   File "[^"]+TestCommon\.py", line \d+, in run
2000     super\(\)\.run\(\*\*kw\)
2001 (?:\s*[~\^]*\s*)?File "[^"]+TestCmd\.py", line \d+, in run
2002     p = self\.start\(program=program,
2003                    interpreter=interpreter,
2004     \.\.\.<2 lines>\.\.\.
2005                    timeout=timeout,
2006                    stdin=stdin\)
2007 (?:\s*[~\^]*\s*)?File \"[^\"]+TestCommon\.py\", line \d+, in start
2008     raise e
2009   File "[^"]+TestCommon\.py", line \d+, in start
2010     return super\(\)\.start\(program, interpreter, arguments,
2011 (?:\s*[~\^]*\s*)?universal_newlines, \*\*kw\)
2012 (?:\s*[~\^]*\s*)?File \"<stdin>\", line \d+, in raise_exception
2013 TypeError: forced TypeError
2014 """)
2015         if sys.version_info[:2] > (3, 12):
2016             expect_stderr = re.compile(expect_enhanced_stderr, re.M)
2017         else:
2018             expect_stderr = re.compile(expect_stderr, re.M)
2019         self.run_execution_test(script, expect_stdout, expect_stderr)
2020
2021     def test_ignore_stderr(self) -> None:
2022         """Test run():  ignore stderr"""
2023
2024         script = lstrip("""\
2025         from TestCommon import TestCommon
2026         tc = TestCommon(program=r'%(stderr_script)s',
2027                         interpreter=r'%(python)s',
2028                         workdir='')
2029         tc.run(stderr = None)
2030         """)
2031
2032         self.run_execution_test(script, "", "")
2033
2034     def test_match_function_stdout(self) -> None:
2035         """Test run():  explicit match function, stdout"""
2036
2037         script = lstrip("""\
2038         def my_match_exact(actual, expect): return actual == expect
2039         from TestCommon import TestCommon, match_re_dotall
2040         tc = TestCommon(program=r'%(pass_script)s',
2041                         interpreter=r'%(python)s',
2042                         workdir="",
2043                         match=match_re_dotall)
2044         tc.run(arguments = "arg1 arg2 arg3",
2045                stdout = r"%(pass_script)s:  STDOUT:  ['arg1', 'arg2', 'arg3']" + "\\n",
2046                match = my_match_exact)
2047         """)
2048
2049         self.run_execution_test(script, "", "")
2050
2051     def test_match_function_stderr(self) -> None:
2052         """Test run():  explicit match function, stderr"""
2053
2054         script = lstrip("""\
2055         def my_match_exact(actual, expect): return actual == expect
2056         from TestCommon import TestCommon, match_re_dotall
2057         tc = TestCommon(program=r'%(stderr_script)s',
2058                         interpreter=r'%(python)s',
2059                         workdir="",
2060                         match=match_re_dotall)
2061         tc.run(arguments = "arg1 arg2 arg3",
2062                stderr = r"%(stderr_script)s:  STDERR:  ['arg1', 'arg2', 'arg3']" + "\\n",
2063                match = my_match_exact)
2064         """)
2065
2066         self.run_execution_test(script, "", "")
2067
2068     def test_matched_status_fails(self) -> None:
2069         """Test run():  matched status, script fails"""
2070
2071         script = lstrip("""\
2072         from TestCommon import TestCommon
2073         tc = TestCommon(program=r'%(fail_script)s',
2074                         interpreter=r'%(python)s',
2075                         workdir='')
2076         tc.run(status = 1)
2077         """)
2078
2079         self.run_execution_test(script, "", "")
2080
2081     def test_matched_stdout(self) -> None:
2082         """Test run():  matched stdout"""
2083
2084         script = lstrip("""\
2085         from TestCommon import TestCommon, match_exact
2086         tc = TestCommon(program=r'%(pass_script)s',
2087                         interpreter=r'%(python)s',
2088                         workdir="",
2089                         match=match_exact)
2090         tc.run(stdout = r"%(pass_script)s:  STDOUT:  []" + "\\n")
2091         """)
2092
2093         self.run_execution_test(script, "", "")
2094
2095     def test_matched_stderr(self) -> None:
2096         """Test run():  matched stderr"""
2097
2098         script = lstrip("""\
2099         from TestCommon import TestCommon, match_exact
2100         tc = TestCommon(program=r'%(stderr_script)s',
2101                         interpreter=r'%(python)s',
2102                         workdir="",
2103                         match=match_exact)
2104         tc.run(stderr = r"%(stderr_script)s:  STDERR:  []" + "\\n")
2105         """)
2106
2107         self.run_execution_test(script, "", "")
2108
2109     def test_mismatched_status_pass(self) -> None:
2110         """Test run():  mismatched status, script passes"""
2111
2112         script = lstrip("""\
2113         from TestCommon import TestCommon
2114         tc = TestCommon(program=r'%(pass_script)s',
2115                         interpreter=r'%(python)s',
2116                         workdir='')
2117         tc.run(status = 1)
2118         """)
2119
2120         expect_stdout = lstrip("""\
2121         %(pass_script)s returned 0 (expected 1)
2122         STDOUT =========================================================================
2123         %(pass_script)s:  STDOUT:  []
2124
2125         STDERR =========================================================================
2126
2127         """)
2128
2129         expect_stderr = lstrip("""\
2130         FAILED test of .*pass
2131         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
2132         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
2133         \\tfrom line \\d+ of <stdin>( \\(<module>\\))?
2134         """)
2135         expect_stderr = re.compile(expect_stderr, re.M)
2136
2137         self.run_execution_test(script, expect_stdout, expect_stderr)
2138
2139     def test_mismatched_status_fail(self) -> None:
2140         """Test run():  mismatched status, script fails"""
2141
2142         script = lstrip("""\
2143         from TestCommon import TestCommon
2144         tc = TestCommon(program=r'%(fail_script)s',
2145                         interpreter=r'%(python)s',
2146                         workdir='')
2147         tc.run(status = 2)
2148         """)
2149
2150         expect_stdout = lstrip("""\
2151         %(fail_script)s returned 1 (expected 2)
2152         STDOUT =========================================================================
2153         %(fail_script)s:  STDOUT:  []
2154
2155         STDERR =========================================================================
2156
2157         """)
2158
2159         expect_stderr = lstrip("""\
2160         FAILED test of .*fail
2161         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
2162         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
2163         \\tfrom line \\d+ of <stdin>( \\(<module>\\))?
2164         """)
2165         expect_stderr = re.compile(expect_stderr, re.M)
2166
2167         self.run_execution_test(script, expect_stdout, expect_stderr)
2168
2169     def test_mismatched_stdout(self) -> None:
2170         """Test run():  mismatched stdout"""
2171
2172         script = lstrip("""\
2173         from TestCommon import TestCommon
2174         tc = TestCommon(program=r'%(pass_script)s',
2175                         interpreter=r'%(python)s',
2176                         workdir='')
2177         tc.run(stdout = "Not found\\n")
2178         """)
2179
2180         expect_stdout = lstrip("""\
2181         match_re: mismatch at line 0:
2182           search re='^Not found$'
2183           line='%(pass_script)s:  STDOUT:  []'
2184         STDOUT =========================================================================
2185         1c1
2186         < Not found
2187         ---
2188         > %(pass_script)s:  STDOUT:  []
2189         """)
2190
2191         expect_stderr = lstrip("""\
2192         FAILED test of .*pass
2193         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
2194         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
2195         \\tfrom line \\d+ of <stdin>( \\(<module>\\))?
2196         """)
2197         expect_stderr = re.compile(expect_stderr, re.M)
2198
2199         self.run_execution_test(script, expect_stdout, expect_stderr)
2200
2201     def test_mismatched_stderr(self) -> None:
2202         """Test run():  mismatched stderr"""
2203
2204         script = lstrip("""\
2205         from TestCommon import TestCommon
2206         tc = TestCommon(program=r'%(stderr_script)s',
2207                         interpreter=r'%(python)s',
2208                         workdir='')
2209         tc.run(stderr = "Not found\\n")
2210         """)
2211
2212         expect_stdout = lstrip("""\
2213         match_re: mismatch at line 0:
2214           search re='^Not found$'
2215           line='%(stderr_script)s:  STDERR:  []'
2216         STDOUT =========================================================================
2217
2218         STDERR =========================================================================
2219         1c1
2220         < Not found
2221         ---
2222         > %(stderr_script)s:  STDERR:  []
2223         """)
2224
2225         expect_stderr = lstrip("""\
2226         FAILED test of .*stderr
2227         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
2228         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
2229         \\tfrom line \\d+ of <stdin>( \\(<module>\\))?
2230         """)
2231         expect_stderr = re.compile(expect_stderr, re.M)
2232
2233         self.run_execution_test(script, expect_stdout, expect_stderr)
2234
2235     def test_option_handling(self) -> None:
2236         """Test run():  option handling"""
2237
2238         script = lstrip("""\
2239         from TestCommon import TestCommon, match_exact
2240         tc = TestCommon(program=r'%(pass_script)s',
2241                         interpreter=r'%(python)s',
2242                         workdir="",
2243                         match=match_exact)
2244         tc.run(options = "opt1 opt2 opt3",
2245                stdout = r"%(pass_script)s:  STDOUT:  ['opt1', 'opt2', 'opt3']" + "\\n")
2246         """)
2247
2248         self.run_execution_test(script, "", "")
2249
2250     def test_options_plus_arguments(self) -> None:
2251         """Test run():  option handling with arguments"""
2252
2253         script = lstrip("""\
2254         from TestCommon import TestCommon, match_exact
2255         tc = TestCommon(program=r'%(pass_script)s',
2256                         interpreter=r'%(python)s',
2257                         workdir="",
2258                         match=match_exact)
2259         tc.run(options = "opt1 opt2 opt3",
2260                arguments = "arg1 arg2 arg3",
2261                stdout = r"%(pass_script)s:  STDOUT:  ['opt1', 'opt2', 'opt3', 'arg1', 'arg2', 'arg3']" + "\\n")
2262         """)
2263
2264         self.run_execution_test(script, "", "")
2265
2266     def test_signal_handling(self) -> None:
2267         """Test run(): signal handling.
2268
2269         Only strange platforms unlikely to support SCons like the
2270         webassembly ones don't support kill(), but keep the test
2271         in place anyway.
2272         """
2273         try:
2274             _ = os.kill
2275         except AttributeError:
2276             sys.stderr.write('can not test, no os.kill ... ')
2277             return
2278
2279         script = lstrip("""\
2280         from TestCommon import TestCommon
2281         tc = TestCommon(program=r'%(signal_script)s',
2282                         interpreter=r'%(python)s',
2283                         workdir='')
2284         tc.run()
2285         """)
2286
2287         self.SIGTERM = f"{'' if sys.platform == 'win32' else '-'}{signal.SIGTERM}"
2288
2289         # Script returns the signal value as a negative number.
2290         expect_stdout = lstrip("""\
2291         %(signal_script)s returned %(SIGTERM)s
2292         STDOUT =========================================================================
2293
2294         STDERR =========================================================================
2295
2296         """)
2297
2298         expect_stderr = lstrip("""\
2299         FAILED test of .*signal
2300         \\tat line \\d+ of .*TestCommon\\.py \\(_complete\\)
2301         \\tfrom line \\d+ of .*TestCommon\\.py \\(run\\)
2302         \\tfrom line \\d+ of <stdin>
2303         """)
2304         expect_stderr = re.compile(expect_stderr, re.M)
2305
2306         self.run_execution_test(script, expect_stdout, expect_stderr)
2307
2308     def test_stdin(self) -> None:
2309         """Test run():  stdin handling"""
2310
2311         script = lstrip("""\
2312         from TestCommon import TestCommon, match_exact
2313         tc = TestCommon(program=r'%(stdin_script)s',
2314                         interpreter=r'%(python)s',
2315                         workdir='',
2316                         match=match_exact)
2317         expect_stdout = r"%(stdin_script)s:  STDOUT:  'input'" + "\\n"
2318         expect_stderr = r"%(stdin_script)s:  STDERR:  'input'" + "\\n"
2319         tc.run(stdin="input\\n", stdout = expect_stdout, stderr = expect_stderr)
2320         """)
2321
2322         expect_stdout = lstrip("""\
2323         %(pass_script)s returned 0 (expected 1)
2324         STDOUT =========================================================================
2325         %(pass_script)s:  STDOUT:  []
2326
2327         STDERR =========================================================================
2328
2329         """)
2330
2331         self.run_execution_test(script, "", "")
2332
2333
2334
2335 class start_TestCase(TestCommonTestCase):
2336     def test_option_handling(self) -> None:
2337         """Test start():  option handling"""
2338
2339         script = lstrip("""\
2340         from TestCommon import TestCommon, match_exact
2341         tc = TestCommon(program=r'%(pass_script)s',
2342                         interpreter=r'%(python)s',
2343                         workdir="",
2344                         match=match_exact)
2345         p = tc.start(options = "opt1 opt2 opt3")
2346         expect = r"%(pass_script)s:  STDOUT:  ['opt1', 'opt2', 'opt3']" + "\\n"
2347         tc.finish(p, stdout = expect)
2348         """)
2349
2350         self.run_execution_test(script, "", "")
2351
2352     def test_options_plus_arguments(self) -> None:
2353         """Test start():  option handling with arguments"""
2354
2355         script = lstrip("""\
2356         from TestCommon import TestCommon, match_exact
2357         tc = TestCommon(program=r'%(pass_script)s',
2358                         interpreter=r'%(python)s',
2359                         workdir="",
2360                         match=match_exact)
2361         p = tc.start(options = "opt1 opt2 opt3",
2362                      arguments = "arg1 arg2 arg3")
2363         expect = r"%(pass_script)s:  STDOUT:  ['opt1', 'opt2', 'opt3', 'arg1', 'arg2', 'arg3']" + "\\n"
2364         tc.finish(p, stdout = expect)
2365         """)
2366
2367         self.run_execution_test(script, "", "")
2368
2369
2370
2371 class skip_test_TestCase(TestCommonTestCase):
2372     def test_skip_test(self) -> None:
2373         """Test skip_test()"""
2374         run_env = self.run_env
2375
2376         script = lstrip("""\
2377         import TestCommon
2378         test = TestCommon.TestCommon(workdir='')
2379         test.skip_test()
2380         """)
2381         run_env.run(program=sys.executable, stdin=script)
2382         stdout = run_env.stdout()
2383         assert stdout == "Skipping test.\n", stdout
2384         stderr = run_env.stderr()
2385         expect = [
2386             "NO RESULT for test at line 3 of <stdin>\n",
2387             "NO RESULT for test at line 3 of <stdin> (<module>)\n",
2388         ]
2389         assert stderr in expect, repr(stderr)
2390
2391         script = lstrip("""\
2392         import TestCommon
2393         test = TestCommon.TestCommon(workdir='')
2394         test.skip_test("skipping test because I said so\\n")
2395         """)
2396         run_env.run(program=sys.executable, stdin=script)
2397         stdout = run_env.stdout()
2398         assert stdout == "skipping test because I said so\n", stdout
2399         stderr = run_env.stderr()
2400         expect = [
2401             "NO RESULT for test at line 3 of <stdin>\n",
2402             "NO RESULT for test at line 3 of <stdin> (<module>)\n",
2403         ]
2404         assert stderr in expect, repr(stderr)
2405
2406         import os
2407         os.environ['TESTCOMMON_PASS_SKIPS'] = '1'
2408
2409         try:
2410             script = lstrip("""\
2411             import TestCommon
2412             test = TestCommon.TestCommon(workdir='')
2413             test.skip_test()
2414             """)
2415             run_env.run(program=sys.executable, stdin=script)
2416             stdout = run_env.stdout()
2417             assert stdout == "Skipping test.\n", stdout
2418             stderr = run_env.stderr()
2419             assert stderr == "PASSED\n", stderr
2420
2421         finally:
2422             del os.environ['TESTCOMMON_PASS_SKIPS']
2423
2424
2425
2426 class variables_TestCase(TestCommonTestCase):
2427     def test_variables(self) -> None:
2428         """Test global variables"""
2429         run_env = self.run_env
2430
2431         variables = [
2432             'fail_test',
2433             'no_result',
2434             'pass_test',
2435             'match_exact',
2436             'match_re',
2437             'match_re_dotall',
2438             'python',
2439             '_python_',
2440             'TestCmd',
2441
2442             'TestCommon',
2443             'exe_suffix',
2444             'obj_suffix',
2445             'shobj_prefix',
2446             'shobj_suffix',
2447             'lib_prefix',
2448             'lib_suffix',
2449             'dll_prefix',
2450             'dll_suffix',
2451         ]
2452
2453         script = "import TestCommon\n" + \
2454                  '\n'.join([f"print(TestCommon.{v})\n" for v in variables])
2455         run_env.run(program=sys.executable, stdin=script)
2456         stderr = run_env.stderr()
2457         assert stderr == "", stderr
2458
2459         script = "from TestCommon import *\n" + \
2460                  '\n'.join([f"print({v})" for v in variables])
2461         run_env.run(program=sys.executable, stdin=script)
2462         stderr = run_env.stderr()
2463         assert stderr == "", stderr
2464
2465
2466
2467 if __name__ == "__main__":
2468     unittest.main()
2469
2470
2471 # Local Variables:
2472 # tab-width:4
2473 # indent-tabs-mode:nil
2474 # End:
2475 # vim: set expandtab tabstop=4 shiftwidth=4: