cpython/Lib/test/test_cmd_line.py at 82b9f5196d4fe5458aa1eff29ecf7ad35278c396 · python/cpython

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

# Tests invocation of the interpreter with various command line arguments

# Most tests are executed with environment variables ignored

# See test_cmd_line_script.py for testing of script execution

import os

import subprocess

import sys

import sysconfig

import tempfile

import unittest

from test import support

from test.support.script_helper import (

spawn_python, kill_python, assert_python_ok, assert_python_failure,

interpreter_requires_environment

)

# Debug build?

Py_DEBUG = hasattr(sys, "gettotalrefcount")

# XXX (ncoghlan): Move to script_helper and make consistent with run_python

def _kill_python_and_exit_code(p):

data = kill_python(p)

returncode = p.wait()

return data, returncode

class CmdLineTest(unittest.TestCase):

def test_directories(self):

assert_python_failure('.')

assert_python_failure('< .')

def verify_valid_flag(self, cmd_line):

rc, out, err = assert_python_ok(*cmd_line)

self.assertTrue(out == b'' or out.endswith(b'\n'))

self.assertNotIn(b'Traceback', out)

self.assertNotIn(b'Traceback', err)

def test_optimize(self):

self.verify_valid_flag('-O')

self.verify_valid_flag('-OO')

def test_site_flag(self):

self.verify_valid_flag('-S')

def test_usage(self):

rc, out, err = assert_python_ok('-h')

self.assertIn(b'usage', out)

def test_version(self):

version = ('Python %d.%d' % sys.version_info[:2]).encode("ascii")

for switch in '-V', '--version', '-VV':

rc, out, err = assert_python_ok(switch)

self.assertFalse(err.startswith(version))

self.assertTrue(out.startswith(version))

def test_verbose(self):

# -v causes imports to write to stderr. If the write to

# stderr itself causes an import to happen (for the output

# codec), a recursion loop can occur.

rc, out, err = assert_python_ok('-v')

self.assertNotIn(b'stack overflow', err)

rc, out, err = assert_python_ok('-vv')

self.assertNotIn(b'stack overflow', err)

@unittest.skipIf(interpreter_requires_environment(),

'Cannot run -E tests when PYTHON env vars are required.')

def test_xoptions(self):

def get_xoptions(*args):

# use subprocess module directly because test.support.script_helper adds

# "-X faulthandler" to the command line

args = (sys.executable, '-E') + args

args += ('-c', 'import sys; print(sys._xoptions)')

out = subprocess.check_output(args)

opts = eval(out.splitlines()[0])

return opts

opts = get_xoptions()

self.assertEqual(opts, {})

opts = get_xoptions('-Xa', '-Xb=c,d=e')

self.assertEqual(opts, {'a': True, 'b': 'c,d=e'})

def test_showrefcount(self):

def run_python(*args):

# this is similar to assert_python_ok but doesn't strip

# the refcount from stderr. It can be replaced once

# assert_python_ok stops doing that.

cmd = [sys.executable]

cmd.extend(args)

PIPE = subprocess.PIPE

p = subprocess.Popen(cmd, stdout=PIPE, stderr=PIPE)

out, err = p.communicate()

p.stdout.close()

p.stderr.close()

rc = p.returncode

self.assertEqual(rc, 0)

return rc, out, err

code = 'import sys; print(sys._xoptions)'

# normally the refcount is hidden

rc, out, err = run_python('-c', code)

self.assertEqual(out.rstrip(), b'{}')

self.assertEqual(err, b'')

# "-X showrefcount" shows the refcount, but only in debug builds

rc, out, err = run_python('-X', 'showrefcount', '-c', code)

self.assertEqual(out.rstrip(), b"{'showrefcount': True}")

if Py_DEBUG:

self.assertRegex(err, br'^\[\d+ refs, \d+ blocks\]')

else:

self.assertEqual(err, b'')

def test_run_module(self):

# Test expected operation of the '-m' switch

# Switch needs an argument

assert_python_failure('-m')

# Check we get an error for a nonexistent module

assert_python_failure('-m', 'fnord43520xyz')

# Check the runpy module also gives an error for

# a nonexistent module

assert_python_failure('-m', 'runpy', 'fnord43520xyz')

# All good if module is located and run successfully

assert_python_ok('-m', 'timeit', '-n', '1')

def test_run_module_bug1764407(self):

# -m and -i need to play well together

# Runs the timeit module and checks the __main__

# namespace has been populated appropriately

p = spawn_python('-i', '-m', 'timeit', '-n', '1')

p.stdin.write(b'Timer\n')

p.stdin.write(b'exit()\n')

data = kill_python(p)

self.assertTrue(data.find(b'1 loop') != -1)

self.assertTrue(data.find(b'__main__.Timer') != -1)

def test_run_code(self):

# Test expected operation of the '-c' switch

# Switch needs an argument

assert_python_failure('-c')

# Check we get an error for an uncaught exception

assert_python_failure('-c', 'raise Exception')

# All good if execution is successful

assert_python_ok('-c', 'pass')

@unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII')

def test_non_ascii(self):

# Test handling of non-ascii data

command = ("assert(ord(%r) == %s)"

% (support.FS_NONASCII, ord(support.FS_NONASCII)))

assert_python_ok('-c', command)

# On Windows, pass bytes to subprocess doesn't test how Python decodes the

# command line, but how subprocess does decode bytes to unicode. Python

# doesn't decode the command line because Windows provides directly the

# arguments as unicode (using wmain() instead of main()).

@unittest.skipIf(sys.platform == 'win32',

'Windows has a native unicode API')

def test_undecodable_code(self):

undecodable = b"\xff"

env = os.environ.copy()

# Use C locale to get ascii for the locale encoding

env['LC_ALL'] = 'C'

code = (

b'import locale; '

b'print(ascii("' + undecodable + b'"), '

b'locale.getpreferredencoding())')

p = subprocess.Popen(

[sys.executable,

# Disable C locale coercion and UTF-8 Mode to not use UTF-8

"-X", "coerce_c_locale=0",

"-X", "utf8=0",

"-c", code],

stdout=subprocess.PIPE, stderr=subprocess.STDOUT,

env=env)

stdout, stderr = p.communicate()

if p.returncode == 1:

# _Py_char2wchar() decoded b'\xff' as '\udcff' (b'\xff' is not

# decodable from ASCII) and run_command() failed on

# PyUnicode_AsUTF8String(). This is the expected behaviour on

# Linux.

pattern = b"Unable to decode the command from the command line:"

elif p.returncode == 0:

# _Py_char2wchar() decoded b'\xff' as '\xff' even if the locale is

# C and the locale encoding is ASCII. It occurs on FreeBSD, Solaris

# and Mac OS X.

pattern = b"'\\xff' "

# The output is followed by the encoding name, an alias to ASCII.

# Examples: "US-ASCII" or "646" (ISO 646, on Solaris).

else:

raise AssertionError("Unknown exit code: %s, output=%a" % (p.returncode, stdout))

if not stdout.startswith(pattern):

raise AssertionError("%a doesn't start with %a" % (stdout, pattern))

@unittest.skipUnless((sys.platform == 'darwin' or

support.is_android), 'test specific to Mac OS X and Android')

def test_osx_android_utf8(self):

def check_output(text):

decoded = text.decode('utf-8', 'surrogateescape')

expected = ascii(decoded).encode('ascii') + b'\n'

env = os.environ.copy()

# C locale gives ASCII locale encoding, but Python uses UTF-8

# to parse the command line arguments on Mac OS X and Android.

env['LC_ALL'] = 'C'

p = subprocess.Popen(

(sys.executable, "-c", "import sys; print(ascii(sys.argv[1]))", text),

stdout=subprocess.PIPE,

env=env)

stdout, stderr = p.communicate()

self.assertEqual(stdout, expected)

self.assertEqual(p.returncode, 0)

# test valid utf-8

text = 'e:\xe9, euro:\u20ac, non-bmp:\U0010ffff'.encode('utf-8')

check_output(text)

# test invalid utf-8

text = (

b'\xff' # invalid byte

b'\xc3\xa9' # valid utf-8 character

b'\xc3\xff' # invalid byte sequence

b'\xed\xa0\x80' # lone surrogate character (invalid)

)

check_output(text)

def test_unbuffered_output(self):

# Test expected operation of the '-u' switch

for stream in ('stdout', 'stderr'):

# Binary is unbuffered

code = ("import os, sys; sys.%s.buffer.write(b'x'); os._exit(0)"

% stream)

rc, out, err = assert_python_ok('-u', '-c', code)

data = err if stream == 'stderr' else out

self.assertEqual(data, b'x', "binary %s not unbuffered" % stream)

# Text is unbuffered

code = ("import os, sys; sys.%s.write('x'); os._exit(0)"

% stream)

rc, out, err = assert_python_ok('-u', '-c', code)

data = err if stream == 'stderr' else out

self.assertEqual(data, b'x', "text %s not unbuffered" % stream)

def test_unbuffered_input(self):

# sys.stdin still works with '-u'

code = ("import sys; sys.stdout.write(sys.stdin.read(1))")

p = spawn_python('-u', '-c', code)

p.stdin.write(b'x')

p.stdin.flush()

data, rc = _kill_python_and_exit_code(p)

self.assertEqual(rc, 0)

self.assertTrue(data.startswith(b'x'), data)

def test_large_PYTHONPATH(self):

path1 = "ABCDE" * 100

path2 = "FGHIJ" * 100

path = path1 + os.pathsep + path2

code = """if 1:

import sys

path = ":".join(sys.path)

path = path.encode("ascii", "backslashreplace")

sys.stdout.buffer.write(path)"""

rc, out, err = assert_python_ok('-S', '-c', code,

PYTHONPATH=path)

self.assertIn(path1.encode('ascii'), out)

self.assertIn(path2.encode('ascii'), out)

def test_empty_PYTHONPATH_issue16309(self):

# On Posix, it is documented that setting PATH to the

# empty string is equivalent to not setting PATH at all,

# which is an exception to the rule that in a string like

# "/bin::/usr/bin" the empty string in the middle gets

# interpreted as '.'

code = """if 1:

import sys

path = ":".join(sys.path)

path = path.encode("ascii", "backslashreplace")

sys.stdout.buffer.write(path)"""

rc1, out1, err1 = assert_python_ok('-c', code, PYTHONPATH="")

rc2, out2, err2 = assert_python_ok('-c', code, __isolated=False)

# regarding to Posix specification, outputs should be equal

# for empty and unset PYTHONPATH

self.assertEqual(out1, out2)

def test_displayhook_unencodable(self):

for encoding in ('ascii', 'latin-1', 'utf-8'):

env = os.environ.copy()

env['PYTHONIOENCODING'] = encoding

p = subprocess.Popen(

[sys.executable, '-i'],

stdin=subprocess.PIPE,

stdout=subprocess.PIPE,

stderr=subprocess.STDOUT,

env=env)

# non-ascii, surrogate, non-BMP printable, non-BMP unprintable

text = "a=\xe9 b=\uDC80 c=\U00010000 d=\U0010FFFF"

p.stdin.write(ascii(text).encode('ascii') + b"\n")

p.stdin.write(b'exit()\n')

data = kill_python(p)

escaped = repr(text).encode(encoding, 'backslashreplace')

self.assertIn(escaped, data)

def check_input(self, code, expected):

with tempfile.NamedTemporaryFile("wb+") as stdin:

sep = os.linesep.encode('ASCII')

stdin.write(sep.join((b'abc', b'def')))

stdin.flush()

stdin.seek(0)

with subprocess.Popen(

(sys.executable, "-c", code),

stdin=stdin, stdout=subprocess.PIPE) as proc:

stdout, stderr = proc.communicate()

self.assertEqual(stdout.rstrip(), expected)

def test_stdin_readline(self):

# Issue #11272: check that sys.stdin.readline() replaces '\r\n' by '\n'

# on Windows (sys.stdin is opened in binary mode)

self.check_input(

"import sys; print(repr(sys.stdin.readline()))",

b"'abc\\n'")

def test_builtin_input(self):

# Issue #11272: check that input() strips newlines ('\n' or '\r\n')

self.check_input(

"print(repr(input()))",

b"'abc'")

def test_output_newline(self):

# Issue 13119 Newline for print() should be \r\n on Windows.

code = """if 1:

import sys

print(1)

print(2)

print(3, file=sys.stderr)

print(4, file=sys.stderr)"""

rc, out, err = assert_python_ok('-c', code)

if sys.platform == 'win32':

self.assertEqual(b'1\r\n2\r\n', out)

self.assertEqual(b'3\r\n4', err)

else:

self.assertEqual(b'1\n2\n', out)

self.assertEqual(b'3\n4', err)

def test_unmached_quote(self):

# Issue #10206: python program starting with unmatched quote

# spewed spaces to stdout

rc, out, err = assert_python_failure('-c', "'")

self.assertRegex(err.decode('ascii', 'ignore'), 'SyntaxError')

self.assertEqual(b'', out)

def test_stdout_flush_at_shutdown(self):

# Issue #5319: if stdout.flush() fails at shutdown, an error should

# be printed out.

code = """if 1:

import os, sys, test.support

test.support.SuppressCrashReport().__enter__()

sys.stdout.write('x')

os.close(sys.stdout.fileno())"""

rc, out, err = assert_python_failure('-c', code)

self.assertEqual(b'', out)

self.assertEqual(120, rc)

self.assertRegex(err.decode('ascii', 'ignore'),

'Exception ignored in.*\nOSError: .*')

def test_closed_stdout(self):

# Issue #13444: if stdout has been explicitly closed, we should

# not attempt to flush it at shutdown.

code = "import sys; sys.stdout.close()"

rc, out, err = assert_python_ok('-c', code)

self.assertEqual(b'', err)

# Issue #7111: Python should work without standard streams

@unittest.skipIf(os.name != 'posix', "test needs POSIX semantics")

def _test_no_stdio(self, streams):

code = """if 1:

import os, sys

for i, s in enumerate({streams}):

if getattr(sys, s) is not None:

os._exit(i + 1)

os._exit(42)""".format(streams=streams)

def preexec():

if 'stdin' in streams:

os.close(0)

if 'stdout' in streams:

os.close(1)

if 'stderr' in streams:

os.close(2)

p = subprocess.Popen(

[sys.executable, "-E", "-c", code],

stdin=subprocess.PIPE,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

preexec_fn=preexec)

out, err = p.communicate()

self.assertEqual(support.strip_python_stderr(err), b'')

self.assertEqual(p.returncode, 42)

def test_no_stdin(self):

self._test_no_stdio(['stdin'])

def test_no_stdout(self):

self._test_no_stdio(['stdout'])

def test_no_stderr(self):

self._test_no_stdio(['stderr'])

def test_no_std_streams(self):

self._test_no_stdio(['stdin', 'stdout', 'stderr'])

def test_hash_randomization(self):

# Verify that -R enables hash randomization:

self.verify_valid_flag('-R')

hashes = []

if os.environ.get('PYTHONHASHSEED', 'random') != 'random':

env = dict(os.environ) # copy

# We need to test that it is enabled by default without

# the environment variable enabling it for us.

del env['PYTHONHASHSEED']

env['__cleanenv'] = '1' # consumed by assert_python_ok()

else:

env = {}

for i in range(3):

code = 'print(hash("spam"))'

rc, out, err = assert_python_ok('-c', code, **env)

self.assertEqual(rc, 0)

hashes.append(out)

hashes = sorted(set(hashes)) # uniq

# Rare chance of failure due to 3 random seeds honestly being equal.

self.assertGreater(len(hashes), 1,

msg='3 runs produced an identical random hash '

' for "spam": {}'.format(hashes))

# Verify that sys.flags contains hash_randomization

code = 'import sys; print("random is", sys.flags.hash_randomization)'

rc, out, err = assert_python_ok('-c', code, PYTHONHASHSEED='')

self.assertIn(b'random is 1', out)

rc, out, err = assert_python_ok('-c', code, PYTHONHASHSEED='random')

self.assertIn(b'random is 1', out)

rc, out, err = assert_python_ok('-c', code, PYTHONHASHSEED='0')

self.assertIn(b'random is 0', out)

rc, out, err = assert_python_ok('-R', '-c', code, PYTHONHASHSEED='0')

self.assertIn(b'random is 1', out)

def test_del___main__(self):

# Issue #15001: PyRun_SimpleFileExFlags() did crash because it kept a

# borrowed reference to the dict of __main__ module and later modify

# the dict whereas the module was destroyed

filename = support.TESTFN

self.addCleanup(support.unlink, filename)

with open(filename, "w") as script:

print("import sys", file=script)

print("del sys.modules['__main__']", file=script)

assert_python_ok(filename)

def test_unknown_options(self):

rc, out, err = assert_python_failure('-E', '-z')

self.assertIn(b'Unknown option: -z', err)

self.assertEqual(err.splitlines().count(b'Unknown option: -z'), 1)

self.assertEqual(b'', out)

# Add "without='-E'" to prevent _assert_python to append -E

# to env_vars and change the output of stderr

rc, out, err = assert_python_failure('-z', without='-E')

self.assertIn(b'Unknown option: -z', err)

self.assertEqual(err.splitlines().count(b'Unknown option: -z'), 1)

self.assertEqual(b'', out)

rc, out, err = assert_python_failure('-a', '-z', without='-E')

self.assertIn(b'Unknown option: -a', err)

# only the first unknown option is reported

self.assertNotIn(b'Unknown option: -z', err)

self.assertEqual(err.splitlines().count(b'Unknown option: -a'), 1)

self.assertEqual(b'', out)

@unittest.skipIf(interpreter_requires_environment(),

'Cannot run -I tests when PYTHON env vars are required.')

def test_isolatedmode(self):

self.verify_valid_flag('-I')

self.verify_valid_flag('-IEs')

rc, out, err = assert_python_ok('-I', '-c',

'from sys import flags as f; '

'print(f.no_user_site, f.ignore_environment, f.isolated)',

# dummyvar to prevent extraneous -E

dummyvar="")

self.assertEqual(out.strip(), b'1 1 1')

with support.temp_cwd() as tmpdir:

fake = os.path.join(tmpdir, "uuid.py")

main = os.path.join(tmpdir, "main.py")

with open(fake, "w") as f:

f.write("raise RuntimeError('isolated mode test')\n")

with open(main, "w") as f:

f.write("import uuid\n")

f.write("print('ok')\n")

self.assertRaises(subprocess.CalledProcessError,

subprocess.check_output,

[sys.executable, main], cwd=tmpdir,

stderr=subprocess.DEVNULL)

out = subprocess.check_output([sys.executable, "-I", main],

cwd=tmpdir)

self.assertEqual(out.strip(), b"ok")

def test_sys_flags_set(self):

# Issue 31845: a startup refactoring broke reading flags from env vars

for value, expected in (("", 0), ("1", 1), ("text", 1), ("2", 2)):

env_vars = dict(

PYTHONDEBUG=value,

PYTHONOPTIMIZE=value,

PYTHONDONTWRITEBYTECODE=value,

PYTHONVERBOSE=value,

)

dont_write_bytecode = int(bool(value))

code = (

"import sys; "

"sys.stderr.write(str(sys.flags)); "

f"""sys.exit(not (

sys.flags.debug == sys.flags.optimize ==

sys.flags.verbose ==

{expected}

and sys.flags.dont_write_bytecode == {dont_write_bytecode}

))"""

)

with self.subTest(envar_value=value):

assert_python_ok('-c', code, **env_vars)

def test_set_pycache_prefix(self):

# sys.pycache_prefix can be set from either -X pycache_prefix or

# PYTHONPYCACHEPREFIX env var, with the former taking precedence.

NO_VALUE = object() # `-X pycache_prefix` with no `=PATH`

cases = [

# (PYTHONPYCACHEPREFIX, -X pycache_prefix, sys.pycache_prefix)

(None, None, None),

('foo', None, 'foo'),

(None, 'bar', 'bar'),

('foo', 'bar', 'bar'),

('foo', '', None),

('foo', NO_VALUE, None),

]

for envval, opt, expected in cases:

exp_clause = "is None" if expected is None else f'== "{expected}"'

code = f"import sys; sys.exit(not sys.pycache_prefix {exp_clause})"

args = ['-c', code]

env = {} if envval is None else {'PYTHONPYCACHEPREFIX': envval}

if opt is NO_VALUE:

args[:0] = ['-X', 'pycache_prefix']

elif opt is not None:

args[:0] = ['-X', f'pycache_prefix={opt}']

with self.subTest(envval=envval, opt=opt):

with support.temp_cwd():

assert_python_ok(*args, **env)

def run_xdev(self, *args, check_exitcode=True, xdev=True):

env = dict(os.environ)

env.pop('PYTHONWARNINGS', None)

env.pop('PYTHONDEVMODE', None)

env.pop('PYTHONMALLOC', None)

if xdev:

args = (sys.executable, '-X', 'dev', *args)

else:

args = (sys.executable, *args)

proc = subprocess.run(args,

stdout=subprocess.PIPE,

stderr=subprocess.STDOUT,

universal_newlines=True,

env=env)

if check_exitcode:

self.assertEqual(proc.returncode, 0, proc)

return proc.stdout.rstrip()

def test_xdev(self):

# sys.flags.dev_mode

code = "import sys; print(sys.flags.dev_mode)"

out = self.run_xdev("-c", code, xdev=False)

self.assertEqual(out, "False")

out = self.run_xdev("-c", code)

self.assertEqual(out, "True")

# Warnings

code = ("import warnings; "

"print(' '.join('%s::%s' % (f[0], f[2].__name__) "

"for f in warnings.filters))")

if Py_DEBUG:

expected_filters = "default::Warning"

else:

expected_filters = ("default::Warning "

"default::DeprecationWarning "

"ignore::DeprecationWarning "

"ignore::PendingDeprecationWarning "

"ignore::ImportWarning "

"ignore::ResourceWarning")

out = self.run_xdev("-c", code)

self.assertEqual(out, expected_filters)

out = self.run_xdev("-b", "-c", code)

self.assertEqual(out, f"default::BytesWarning {expected_filters}")

out = self.run_xdev("-bb", "-c", code)

self.assertEqual(out, f"error::BytesWarning {expected_filters}")

out = self.run_xdev("-Werror", "-c", code)

self.assertEqual(out, f"error::Warning {expected_filters}")

# Memory allocator debug hooks

try:

import _testcapi

except ImportError:

pass

else:

code = "import _testcapi; print(_testcapi.pymem_getallocatorsname())"

with support.SuppressCrashReport():

out = self.run_xdev("-c", code, check_exitcode=False)

if support.with_pymalloc():

alloc_name = "pymalloc_debug"

else:

alloc_name = "malloc_debug"

self.assertEqual(out, alloc_name)

# Faulthandler

try:

import faulthandler

except ImportError:

pass

else:

code = "import faulthandler; print(faulthandler.is_enabled())"

out = self.run_xdev("-c", code)

self.assertEqual(out, "True")

def check_warnings_filters(self, cmdline_option, envvar, use_pywarning=False):

if use_pywarning:

code = ("import sys; from test.support import import_fresh_module; "

"warnings = import_fresh_module('warnings', blocked=['_warnings']); ")

else:

code = "import sys, warnings; "

code += ("print(' '.join('%s::%s' % (f[0], f[2].__name__) "

"for f in warnings.filters))")

args = (sys.executable, '-W', cmdline_option, '-bb', '-c', code)

env = dict(os.environ)

env.pop('PYTHONDEVMODE', None)

env["PYTHONWARNINGS"] = envvar

proc = subprocess.run(args,

stdout=subprocess.PIPE,

stderr=subprocess.STDOUT,

universal_newlines=True,

env=env)

self.assertEqual(proc.returncode, 0, proc)

return proc.stdout.rstrip()

def test_warnings_filter_precedence(self):

expected_filters = ("error::BytesWarning "

"once::UserWarning "

"always::UserWarning")

if not Py_DEBUG:

expected_filters += (" "

"default::DeprecationWarning "

"ignore::DeprecationWarning "

"ignore::PendingDeprecationWarning "

"ignore::ImportWarning "

"ignore::ResourceWarning")

out = self.check_warnings_filters("once::UserWarning",

"always::UserWarning")

self.assertEqual(out, expected_filters)

out = self.check_warnings_filters("once::UserWarning",

"always::UserWarning",

use_pywarning=True)

self.assertEqual(out, expected_filters)

def check_pythonmalloc(self, env_var, name):

code = 'import _testcapi; print(_testcapi.pymem_getallocatorsname())'

env = dict(os.environ)

env.pop('PYTHONDEVMODE', None)

if env_var is not None:

env['PYTHONMALLOC'] = env_var

else:

env.pop('PYTHONMALLOC', None)

args = (sys.executable, '-c', code)

proc = subprocess.run(args,

stdout=subprocess.PIPE,

stderr=subprocess.STDOUT,

universal_newlines=True,

env=env)

self.assertEqual(proc.stdout.rstrip(), name)

self.assertEqual(proc.returncode, 0)

def test_pythonmalloc(self):

# Test the PYTHONMALLOC environment variable

pymalloc = support.with_pymalloc()

if pymalloc:

default_name = 'pymalloc_debug' if Py_DEBUG else 'pymalloc'

default_name_debug = 'pymalloc_debug'

else:

default_name = 'malloc_debug' if Py_DEBUG else 'malloc'

default_name_debug = 'malloc_debug'

tests = [

(None, default_name),

('debug', default_name_debug),

('malloc', 'malloc'),

('malloc_debug', 'malloc_debug'),

]

if pymalloc:

tests.extend((

('pymalloc', 'pymalloc'),

('pymalloc_debug', 'pymalloc_debug'),

))

for env_var, name in tests:

with self.subTest(env_var=env_var, name=name):

self.check_pythonmalloc(env_var, name)

def test_pythondevmode_env(self):

# Test the PYTHONDEVMODE environment variable

code = "import sys; print(sys.flags.dev_mode)"

env = dict(os.environ)

env.pop('PYTHONDEVMODE', None)

args = (sys.executable, '-c', code)

proc = subprocess.run(args, stdout=subprocess.PIPE,

universal_newlines=True, env=env)

self.assertEqual(proc.stdout.rstrip(), 'False')

self.assertEqual(proc.returncode, 0, proc)

env['PYTHONDEVMODE'] = '1'

proc = subprocess.run(args, stdout=subprocess.PIPE,

universal_newlines=True, env=env)

self.assertEqual(proc.stdout.rstrip(), 'True')

self.assertEqual(proc.returncode, 0, proc)

@unittest.skipUnless(sys.platform == 'win32',

'bpo-32457 only applies on Windows')

def test_argv0_normalization(self):

args = sys.executable, '-c', 'print(0)'

prefix, exe = os.path.split(sys.executable)

executable = prefix + '\\.\\.\\.\\' + exe

proc = subprocess.run(args, stdout=subprocess.PIPE,

executable=executable)

self.assertEqual(proc.returncode, 0, proc)

self.assertEqual(proc.stdout.strip(), b'0')

@unittest.skipIf(interpreter_requires_environment(),

'Cannot run -I tests when PYTHON env vars are required.')

class IgnoreEnvironmentTest(unittest.TestCase):

def run_ignoring_vars(self, predicate, **env_vars):

# Runs a subprocess with -E set, even though we're passing

# specific environment variables

# Logical inversion to match predicate check to a zero return

# code indicating success

code = "import sys; sys.stderr.write(str(sys.flags)); sys.exit(not ({}))".format(predicate)

return assert_python_ok('-E', '-c', code, **env_vars)

def test_ignore_PYTHONPATH(self):

path = "should_be_ignored"

self.run_ignoring_vars("'{}' not in sys.path".format(path),

PYTHONPATH=path)

def test_ignore_PYTHONHASHSEED(self):

self.run_ignoring_vars("sys.flags.hash_randomization == 1",

PYTHONHASHSEED="0")

def test_sys_flags_not_set(self):

# Issue 31845: a startup refactoring broke reading flags from env vars

expected_outcome = """

(sys.flags.debug == sys.flags.optimize ==

sys.flags.dont_write_bytecode == sys.flags.verbose == 0)

"""

self.run_ignoring_vars(

expected_outcome,

PYTHONDEBUG="1",

PYTHONOPTIMIZE="1",

PYTHONDONTWRITEBYTECODE="1",

PYTHONVERBOSE="1",

)

def test_main():

support.run_unittest(CmdLineTest, IgnoreEnvironmentTest)

support.reap_children()

if __name__ == "__main__":

test_main()

FilesExpand file tree

test_cmd_line.py

Latest commit

History

test_cmd_line.py

File metadata and controls