| import io | |
| import itertools | |
| import os | |
| import shlex | |
| import string | |
| import tempfile | |
| import unittest | |
| from unittest.mock import patch | |
| from test.support import cpython_only | |
| from test.support import import_helper | |
| # The original test data set was from shellwords, by Hartmut Goebel. | |
| data = r"""x|x| | |
| foo bar|foo|bar| | |
| foo bar|foo|bar| | |
| foo bar |foo|bar| | |
| foo bar bla fasel|foo|bar|bla|fasel| | |
| x y z xxxx|x|y|z|xxxx| | |
| \x bar|\|x|bar| | |
| \ x bar|\|x|bar| | |
| \ bar|\|bar| | |
| foo \x bar|foo|\|x|bar| | |
| foo \ x bar|foo|\|x|bar| | |
| foo \ bar|foo|\|bar| | |
| foo "bar" bla|foo|"bar"|bla| | |
| "foo" "bar" "bla"|"foo"|"bar"|"bla"| | |
| "foo" bar "bla"|"foo"|bar|"bla"| | |
| "foo" bar bla|"foo"|bar|bla| | |
| foo 'bar' bla|foo|'bar'|bla| | |
| 'foo' 'bar' 'bla'|'foo'|'bar'|'bla'| | |
| 'foo' bar 'bla'|'foo'|bar|'bla'| | |
| 'foo' bar bla|'foo'|bar|bla| | |
| blurb foo"bar"bar"fasel" baz|blurb|foo"bar"bar"fasel"|baz| | |
| blurb foo'bar'bar'fasel' baz|blurb|foo'bar'bar'fasel'|baz| | |
| ""|""| | |
| ''|''| | |
| foo "" bar|foo|""|bar| | |
| foo '' bar|foo|''|bar| | |
| foo "" "" "" bar|foo|""|""|""|bar| | |
| foo '' '' '' bar|foo|''|''|''|bar| | |
| \""|\|""| | |
| "\"|"\"| | |
| "foo\ bar"|"foo\ bar"| | |
| "foo\\ bar"|"foo\\ bar"| | |
| "foo\\ bar\"|"foo\\ bar\"| | |
| "foo\\" bar\""|"foo\\"|bar|\|""| | |
| "foo\\ bar\" dfadf"|"foo\\ bar\"|dfadf"| | |
| "foo\\\ bar\" dfadf"|"foo\\\ bar\"|dfadf"| | |
| "foo\\\x bar\" dfadf"|"foo\\\x bar\"|dfadf"| | |
| "foo\x bar\" dfadf"|"foo\x bar\"|dfadf"| | |
| \''|\|''| | |
| 'foo\ bar'|'foo\ bar'| | |
| 'foo\\ bar'|'foo\\ bar'| | |
| "foo\\\x bar\" df'a\ 'df'|"foo\\\x bar\"|df'a|\|'df'| | |
| \"foo"|\|"foo"| | |
| \"foo"\x|\|"foo"|\|x| | |
| "foo\x"|"foo\x"| | |
| "foo\ "|"foo\ "| | |
| foo\ xx|foo|\|xx| | |
| foo\ x\x|foo|\|x|\|x| | |
| foo\ x\x\""|foo|\|x|\|x|\|""| | |
| "foo\ x\x"|"foo\ x\x"| | |
| "foo\ x\x\\"|"foo\ x\x\\"| | |
| "foo\ x\x\\""foobar"|"foo\ x\x\\"|"foobar"| | |
| "foo\ x\x\\"\''"foobar"|"foo\ x\x\\"|\|''|"foobar"| | |
| "foo\ x\x\\"\'"fo'obar"|"foo\ x\x\\"|\|'"fo'|obar"| | |
| "foo\ x\x\\"\'"fo'obar" 'don'\''t'|"foo\ x\x\\"|\|'"fo'|obar"|'don'|\|''|t'| | |
| 'foo\ bar'|'foo\ bar'| | |
| 'foo\\ bar'|'foo\\ bar'| | |
| foo\ bar|foo|\|bar| | |
| foo#bar\nbaz|foobaz| | |
| :-) ;-)|:|-|)|;|-|)| | |
| áéíóú|á|é|í|ó|ú| | |
| """ | |
| posix_data = r"""x|x| | |
| foo bar|foo|bar| | |
| foo bar|foo|bar| | |
| foo bar |foo|bar| | |
| foo bar bla fasel|foo|bar|bla|fasel| | |
| x y z xxxx|x|y|z|xxxx| | |
| \x bar|x|bar| | |
| \ x bar| x|bar| | |
| \ bar| bar| | |
| foo \x bar|foo|x|bar| | |
| foo \ x bar|foo| x|bar| | |
| foo \ bar|foo| bar| | |
| foo "bar" bla|foo|bar|bla| | |
| "foo" "bar" "bla"|foo|bar|bla| | |
| "foo" bar "bla"|foo|bar|bla| | |
| "foo" bar bla|foo|bar|bla| | |
| foo 'bar' bla|foo|bar|bla| | |
| 'foo' 'bar' 'bla'|foo|bar|bla| | |
| 'foo' bar 'bla'|foo|bar|bla| | |
| 'foo' bar bla|foo|bar|bla| | |
| blurb foo"bar"bar"fasel" baz|blurb|foobarbarfasel|baz| | |
| blurb foo'bar'bar'fasel' baz|blurb|foobarbarfasel|baz| | |
| ""|| | |
| ''|| | |
| foo "" bar|foo||bar| | |
| foo '' bar|foo||bar| | |
| foo "" "" "" bar|foo||||bar| | |
| foo '' '' '' bar|foo||||bar| | |
| \"|"| | |
| "\""|"| | |
| "foo\ bar"|foo\ bar| | |
| "foo\\ bar"|foo\ bar| | |
| "foo\\ bar\""|foo\ bar"| | |
| "foo\\" bar\"|foo\|bar"| | |
| "foo\\ bar\" dfadf"|foo\ bar" dfadf| | |
| "foo\\\ bar\" dfadf"|foo\\ bar" dfadf| | |
| "foo\\\x bar\" dfadf"|foo\\x bar" dfadf| | |
| "foo\x bar\" dfadf"|foo\x bar" dfadf| | |
| \'|'| | |
| 'foo\ bar'|foo\ bar| | |
| 'foo\\ bar'|foo\\ bar| | |
| "foo\\\x bar\" df'a\ 'df"|foo\\x bar" df'a\ 'df| | |
| \"foo|"foo| | |
| \"foo\x|"foox| | |
| "foo\x"|foo\x| | |
| "foo\ "|foo\ | | |
| foo\ xx|foo xx| | |
| foo\ x\x|foo xx| | |
| foo\ x\x\"|foo xx"| | |
| "foo\ x\x"|foo\ x\x| | |
| "foo\ x\x\\"|foo\ x\x\| | |
| "foo\ x\x\\""foobar"|foo\ x\x\foobar| | |
| "foo\ x\x\\"\'"foobar"|foo\ x\x\'foobar| | |
| "foo\ x\x\\"\'"fo'obar"|foo\ x\x\'fo'obar| | |
| "foo\ x\x\\"\'"fo'obar" 'don'\''t'|foo\ x\x\'fo'obar|don't| | |
| "foo\ x\x\\"\'"fo'obar" 'don'\''t' \\|foo\ x\x\'fo'obar|don't|\| | |
| 'foo\ bar'|foo\ bar| | |
| 'foo\\ bar'|foo\\ bar| | |
| foo\ bar|foo bar| | |
| foo#bar\nbaz|foo|baz| | |
| :-) ;-)|:-)|;-)| | |
| áéíóú|áéíóú| | |
| """ | |
| class ShlexTest(unittest.TestCase): | |
| def setUp(self): | |
| self.data = [x.split("|")[:-1] | |
| for x in data.splitlines()] | |
| self.posix_data = [x.split("|")[:-1] | |
| for x in posix_data.splitlines()] | |
| for item in self.data: | |
| item[0] = item[0].replace(r"\n", "\n") | |
| for item in self.posix_data: | |
| item[0] = item[0].replace(r"\n", "\n") | |
| def splitTest(self, data, comments): | |
| for i in range(len(data)): | |
| l = shlex.split(data[i][0], comments=comments) | |
| self.assertEqual(l, data[i][1:], | |
| "%s: %s != %s" % | |
| (data[i][0], l, data[i][1:])) | |
| def oldSplit(self, s): | |
| ret = [] | |
| lex = shlex.shlex(io.StringIO(s)) | |
| tok = lex.get_token() | |
| while tok: | |
| ret.append(tok) | |
| tok = lex.get_token() | |
| return ret | |
| def testSplitNone(self): | |
| with self.assertRaises(ValueError): | |
| shlex.split(None) | |
| def testSplitPosix(self): | |
| """Test data splitting with posix parser""" | |
| self.splitTest(self.posix_data, comments=True) | |
| def testCompat(self): | |
| """Test compatibility interface""" | |
| for i in range(len(self.data)): | |
| l = self.oldSplit(self.data[i][0]) | |
| self.assertEqual(l, self.data[i][1:], | |
| "%s: %s != %s" % | |
| (self.data[i][0], l, self.data[i][1:])) | |
| def testSyntaxSplitAmpersandAndPipe(self): | |
| """Test handling of syntax splitting of &, |""" | |
| # Could take these forms: &&, &, |&, ;&, ;;& | |
| # of course, the same applies to | and || | |
| # these should all parse to the same output | |
| for delimiter in ('&&', '&', '|&', ';&', ';;&', | |
| '||', '|', '&|', ';|', ';;|'): | |
| src = ['echo hi %s echo bye' % delimiter, | |
| 'echo hi%secho bye' % delimiter] | |
| ref = ['echo', 'hi', delimiter, 'echo', 'bye'] | |
| for ss, ws in itertools.product(src, (False, True)): | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| s.whitespace_split = ws | |
| result = list(s) | |
| self.assertEqual(ref, result, | |
| "While splitting '%s' [ws=%s]" % (ss, ws)) | |
| def testSyntaxSplitSemicolon(self): | |
| """Test handling of syntax splitting of ;""" | |
| # Could take these forms: ;, ;;, ;&, ;;& | |
| # these should all parse to the same output | |
| for delimiter in (';', ';;', ';&', ';;&'): | |
| src = ['echo hi %s echo bye' % delimiter, | |
| 'echo hi%s echo bye' % delimiter, | |
| 'echo hi%secho bye' % delimiter] | |
| ref = ['echo', 'hi', delimiter, 'echo', 'bye'] | |
| for ss, ws in itertools.product(src, (False, True)): | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| s.whitespace_split = ws | |
| result = list(s) | |
| self.assertEqual(ref, result, | |
| "While splitting '%s' [ws=%s]" % (ss, ws)) | |
| def testSyntaxSplitRedirect(self): | |
| """Test handling of syntax splitting of >""" | |
| # of course, the same applies to <, | | |
| # these should all parse to the same output | |
| for delimiter in ('<', '|'): | |
| src = ['echo hi %s out' % delimiter, | |
| 'echo hi%s out' % delimiter, | |
| 'echo hi%sout' % delimiter] | |
| ref = ['echo', 'hi', delimiter, 'out'] | |
| for ss, ws in itertools.product(src, (False, True)): | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| result = list(s) | |
| self.assertEqual(ref, result, | |
| "While splitting '%s' [ws=%s]" % (ss, ws)) | |
| def testSyntaxSplitParen(self): | |
| """Test handling of syntax splitting of ()""" | |
| # these should all parse to the same output | |
| src = ['( echo hi )', | |
| '(echo hi)'] | |
| ref = ['(', 'echo', 'hi', ')'] | |
| for ss, ws in itertools.product(src, (False, True)): | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| s.whitespace_split = ws | |
| result = list(s) | |
| self.assertEqual(ref, result, | |
| "While splitting '%s' [ws=%s]" % (ss, ws)) | |
| def testSyntaxSplitCustom(self): | |
| """Test handling of syntax splitting with custom chars""" | |
| ss = "~/a&&b-c --color=auto||d *.py?" | |
| ref = ['~/a', '&', '&', 'b-c', '--color=auto', '||', 'd', '*.py?'] | |
| s = shlex.shlex(ss, punctuation_chars="|") | |
| result = list(s) | |
| self.assertEqual(ref, result, "While splitting '%s' [ws=False]" % ss) | |
| ref = ['~/a&&b-c', '--color=auto', '||', 'd', '*.py?'] | |
| s = shlex.shlex(ss, punctuation_chars="|") | |
| s.whitespace_split = True | |
| result = list(s) | |
| self.assertEqual(ref, result, "While splitting '%s' [ws=True]" % ss) | |
| def testTokenTypes(self): | |
| """Test that tokens are split with types as expected.""" | |
| for source, expected in ( | |
| ('a && b || c', | |
| [('a', 'a'), ('&&', 'c'), ('b', 'a'), | |
| ('||', 'c'), ('c', 'a')]), | |
| ): | |
| s = shlex.shlex(source, punctuation_chars=True) | |
| observed = [] | |
| while True: | |
| t = s.get_token() | |
| if t == s.eof: | |
| break | |
| if t[0] in s.punctuation_chars: | |
| tt = 'c' | |
| else: | |
| tt = 'a' | |
| observed.append((t, tt)) | |
| self.assertEqual(observed, expected) | |
| def testPunctuationInWordChars(self): | |
| """Test that any punctuation chars are removed from wordchars""" | |
| s = shlex.shlex('a_b__c', punctuation_chars='_') | |
| self.assertNotIn('_', s.wordchars) | |
| self.assertEqual(list(s), ['a', '_', 'b', '__', 'c']) | |
| def testPunctuationWithWhitespaceSplit(self): | |
| """Test that with whitespace_split, behaviour is as expected""" | |
| s = shlex.shlex('a && b || c', punctuation_chars='&') | |
| # whitespace_split is False, so splitting will be based on | |
| # punctuation_chars | |
| self.assertEqual(list(s), ['a', '&&', 'b', '|', '|', 'c']) | |
| s = shlex.shlex('a && b || c', punctuation_chars='&') | |
| s.whitespace_split = True | |
| # whitespace_split is True, so splitting will be based on | |
| # white space | |
| self.assertEqual(list(s), ['a', '&&', 'b', '||', 'c']) | |
| def testPunctuationWithPosix(self): | |
| """Test that punctuation_chars and posix behave correctly together.""" | |
| # see Issue #29132 | |
| s = shlex.shlex('f >"abc"', posix=True, punctuation_chars=True) | |
| self.assertEqual(list(s), ['f', '>', 'abc']) | |
| s = shlex.shlex('f >\\"abc\\"', posix=True, punctuation_chars=True) | |
| self.assertEqual(list(s), ['f', '>', '"abc"']) | |
| def testEmptyStringHandling(self): | |
| """Test that parsing of empty strings is correctly handled.""" | |
| # see Issue #21999 | |
| expected = ['', ')', 'abc'] | |
| for punct in (False, True): | |
| s = shlex.shlex("'')abc", posix=True, punctuation_chars=punct) | |
| slist = list(s) | |
| self.assertEqual(slist, expected) | |
| expected = ["''", ')', 'abc'] | |
| s = shlex.shlex("'')abc", punctuation_chars=True) | |
| self.assertEqual(list(s), expected) | |
| def testUnicodeHandling(self): | |
| """Test punctuation_chars and whitespace_split handle unicode.""" | |
| ss = "\u2119\u01b4\u2602\u210c\u00f8\u1f24" | |
| # Should be parsed as one complete token (whitespace_split=True). | |
| ref = ['\u2119\u01b4\u2602\u210c\u00f8\u1f24'] | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| s.whitespace_split = True | |
| self.assertEqual(list(s), ref) | |
| # Without whitespace_split, uses wordchars and splits on all. | |
| ref = ['\u2119', '\u01b4', '\u2602', '\u210c', '\u00f8', '\u1f24'] | |
| s = shlex.shlex(ss, punctuation_chars=True) | |
| self.assertEqual(list(s), ref) | |
| def testQuote(self): | |
| safeunquoted = string.ascii_letters + string.digits + '@%_-+=:,./' | |
| unicode_sample = '\xe9\xe0\xdf' # e + acute accent, a + grave, sharp s | |
| unsafe = '"`$\\!' + unicode_sample | |
| self.assertEqual(shlex.quote(''), "''") | |
| self.assertEqual(shlex.quote(None), "''") | |
| self.assertEqual(shlex.quote(safeunquoted), safeunquoted) | |
| self.assertEqual(shlex.quote('test file name'), "'test file name'") | |
| for u in unsafe: | |
| self.assertEqual(shlex.quote('test%sname' % u), | |
| "'test%sname'" % u) | |
| for u in unsafe: | |
| self.assertEqual(shlex.quote("test%s'name'" % u), | |
| "'test%s'\"'\"'name'\"'\"''" % u) | |
| self.assertRaises(TypeError, shlex.quote, 42) | |
| self.assertRaises(TypeError, shlex.quote, b"abc") | |
| def testForceQuote(self): | |
| self.assertEqual(shlex.quote("spam"), "spam") | |
| self.assertEqual(shlex.quote("spam", force=False), "spam") | |
| self.assertEqual(shlex.quote("spam", force=True), "'spam'") | |
| self.assertEqual(shlex.quote("spam eggs", force=False), "'spam eggs'") | |
| self.assertEqual(shlex.quote("spam eggs", force=True), "'spam eggs'") | |
| self.assertEqual(shlex.quote("two's-complement", force=False), "'two'\"'\"'s-complement'") | |
| def testJoin(self): | |
| for split_command, command in [ | |
| (['a ', 'b'], "'a ' b"), | |
| (['a', ' b'], "a ' b'"), | |
| (['a', ' ', 'b'], "a ' ' b"), | |
| (['"a', 'b"'], '\'"a\' \'b"\''), | |
| ]: | |
| with self.subTest(command=command): | |
| joined = shlex.join(split_command) | |
| self.assertEqual(joined, command) | |
| def testJoinRoundtrip(self): | |
| all_data = self.data + self.posix_data | |
| for command, *split_command in all_data: | |
| with self.subTest(command=command): | |
| joined = shlex.join(split_command) | |
| resplit = shlex.split(joined) | |
| self.assertEqual(split_command, resplit) | |
| def testPunctuationCharsReadOnly(self): | |
| punctuation_chars = "/|$%^" | |
| shlex_instance = shlex.shlex(punctuation_chars=punctuation_chars) | |
| self.assertEqual(shlex_instance.punctuation_chars, punctuation_chars) | |
| with self.assertRaises(AttributeError): | |
| shlex_instance.punctuation_chars = False | |
| def testLinenoAfterNewLine(self): | |
| s = shlex.shlex("line 1\nline 2") | |
| self.assertEqual(s.lineno, 1) # before consumption | |
| list(s) | |
| self.assertEqual(s.lineno, 2) | |
| def testLinenoAfterComment(self): | |
| """Comment handler increments lineno even without a trailing newline.""" | |
| s = shlex.shlex("line 1 # line 2") | |
| list(s) | |
| self.assertEqual(s.lineno, 2) | |
| def testPushToken(self): | |
| s = shlex.shlex("b c") | |
| s.push_token("a") | |
| self.assertListEqual(list(s), ["a", "b", "c"]) | |
| def testPushTokenLifo(self): | |
| s = shlex.shlex("") | |
| s.push_token("first") | |
| s.push_token("last") | |
| self.assertListEqual(list(s), ["last", "first"]) | |
| def testPushTokenDebug(self): | |
| s = shlex.shlex("") | |
| s.debug = 1 | |
| tok = "a" | |
| with patch("builtins.print") as mock_print: | |
| s.push_token(tok) | |
| mock_print.assert_called_once_with(f"shlex: pushing token {tok!r}") | |
| def testPushSourceString(self): | |
| s = shlex.shlex("world") | |
| s.push_source("hello") | |
| self.assertListEqual(list(s), ["hello", "world"]) | |
| def testPushSourceStream(self): | |
| s = shlex.shlex("world") | |
| s.push_source(io.StringIO("hello")) | |
| self.assertListEqual(list(s), ["hello", "world"]) | |
| def testPushSourceStreamDebug(self): | |
| s = shlex.shlex("") | |
| stream = io.StringIO("hello") | |
| s.debug = 1 | |
| with patch("builtins.print") as mock_print: | |
| s.push_source(stream) | |
| mock_print.assert_called_once_with(f"shlex: pushing to stream {stream}") | |
| def testPushSourceNewfile(self): | |
| """shlex.push_source sets infile to newfile; pop_source restores the original on exhaustion.""" | |
| original_file = "original.sh" | |
| new_file = "new.sh" | |
| s = shlex.shlex("b", infile=original_file) | |
| s.debug = 1 | |
| with patch("builtins.print") as mock_print: | |
| s.push_source("a", newfile=new_file) | |
| mock_print.assert_called_once_with(f"shlex: pushing to file {new_file}") | |
| self.assertEqual(s.infile, new_file) | |
| s.debug = 0 | |
| list(s) | |
| self.assertEqual(s.infile, original_file) | |
| def testPopSourceDebug(self): | |
| """pop_source emits debug output when debug is set.""" | |
| s = shlex.shlex("b") | |
| original_stream = s.instream | |
| s.push_source("a") | |
| s.debug = 1 | |
| with patch("builtins.print") as mock_print: | |
| list(s) # exhausts pushed source and triggers pop_source internally | |
| mock_print.assert_any_call(f"shlex: popping to {original_stream}, line 1") | |
| def testErrorLeaderTracksPosition(self): | |
| infile_label = "test.sh" | |
| s = shlex.shlex("line 1\nline 2", infile=infile_label) | |
| list(s) | |
| result = s.error_leader() | |
| self.assertEqual(result, f'"{infile_label}", line 2: ') | |
| def testErrorLeaderOverrides(self): | |
| s = shlex.shlex("foo", infile="original.sh") | |
| infile_label_override = "override.sh" | |
| lineno_override = 42 | |
| result = s.error_leader(infile=infile_label_override, lineno=lineno_override) | |
| self.assertEqual(result, f'"{infile_label_override}", line {lineno_override}: ') | |
| def testNoClosingQuotation(self): | |
| s = shlex.shlex('"foo') | |
| with self.assertRaisesRegex(ValueError, "No closing quotation"): | |
| list(s) | |
| def testNoEscapedCharacter(self): | |
| s = shlex.shlex("\\", posix=True) | |
| with self.assertRaisesRegex(ValueError, "No escaped character"): | |
| list(s) | |
| def testSourcehookStripsQuotes(self): | |
| with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete_on_close=False) as f: | |
| f.write("hello") | |
| f.close() | |
| s = shlex.shlex("") | |
| newfile, stream = s.sourcehook(f'"{f.name}"') | |
| stream.close() | |
| self.assertEqual(newfile, f.name) | |
| def testSourcehookAbsolutePath(self): | |
| with tempfile.NamedTemporaryFile(mode="w", delete_on_close=False) as f: | |
| f.close() | |
| s = shlex.shlex("", infile="/some/dir/main.sh") | |
| newfile, stream = s.sourcehook(f.name) | |
| stream.close() | |
| self.assertEqual(newfile, f.name) | |
| def testSourcehookRelativePath(self): | |
| with tempfile.TemporaryDirectory() as d: | |
| fpath = os.path.join(d, "included.sh") | |
| with open(fpath, "w"): | |
| pass | |
| s = shlex.shlex("", infile=os.path.join(d, "main.sh")) | |
| newfile, stream = s.sourcehook("included.sh") | |
| stream.close() | |
| self.assertEqual(newfile, fpath) | |
| def testSourceInclusion(self): | |
| """shlex.source sets a trigger keyword: when the lexer reads a token equal | |
| to it, the next token is consumed as a filename and passed to | |
| sourcehook, which returns a stream to push onto the input stack. | |
| Tokens flow from that stream first, then resume from the original. | |
| """ | |
| s = shlex.shlex("trigger filename remaining") | |
| s.source = "trigger" | |
| s.sourcehook = lambda f: (f, io.StringIO("included")) | |
| self.assertEqual(list(s), ["included", "remaining"]) | |
| def testGetTokenPopsPushbackDebug(self): | |
| s = shlex.shlex("") | |
| s.push_token("hello") | |
| s.debug = 1 # set after push_token to isolate the pop-token branch | |
| with patch("builtins.print") as mock_print: | |
| tok = s.get_token() | |
| self.assertEqual(tok, "hello") | |
| mock_print.assert_called_once_with("shlex: popping token 'hello'") | |
| def testDebugWhitespaceInWhitespaceState(self): | |
| s = shlex.shlex(" a") | |
| s.debug = 2 | |
| with patch("builtins.print") as mock_print: | |
| list(s) | |
| mock_print.assert_any_call("shlex: I see whitespace in whitespace state") | |
| def testDebugWhitespaceInWordState(self): | |
| s = shlex.shlex("a b") | |
| s.debug = 2 | |
| with patch("builtins.print") as mock_print: | |
| list(s) | |
| mock_print.assert_any_call("shlex: I see whitespace in word state") | |
| def testDebugPunctuationInWordState(self): | |
| s = shlex.shlex("a(") | |
| s.debug = 2 | |
| with patch("builtins.print") as mock_print: | |
| list(s) | |
| mock_print.assert_any_call("shlex: I see punctuation in word state") | |
| def testDebugRawToken(self): | |
| s = shlex.shlex("hello") | |
| s.debug = 2 | |
| with patch("builtins.print") as mock_print: | |
| list(s) | |
| mock_print.assert_any_call("shlex: raw token='hello'") | |
| def testDebugEOFInQuote(self): | |
| s = shlex.shlex('"oops', posix=True) | |
| s.debug = 2 | |
| with patch('builtins.print') as mock_print: | |
| with self.assertRaises(ValueError): | |
| list(s) | |
| msgs = [call.args[0] for call in mock_print.call_args_list] | |
| self.assertTrue(any("EOF in quotes" in m for m in msgs)) | |
| def testDebugEOFInEscape(self): | |
| s = shlex.shlex("oops\\", posix=True) | |
| s.debug = 2 | |
| with patch("builtins.print") as mock_print: | |
| with self.assertRaises(ValueError): | |
| list(s) | |
| msgs = [call.args[0] for call in mock_print.call_args_list] | |
| self.assertTrue(any("EOF in escape" in m for m in msgs)) | |
| def testDebugStateTrace(self): | |
| s = shlex.shlex("a") | |
| s.debug = 3 | |
| with patch("builtins.print") as mock_print: | |
| list(s) | |
| mock_print.assert_any_call("shlex: in state ' ' I see character: 'a'") | |
| @cpython_only | |
| def test_lazy_imports(self): | |
| import_helper.ensure_lazy_imports('shlex', {'collections', 're', 'os'}) | |
| # Allow this test to be used with old shlex.py | |
| if not getattr(shlex, "split", None): | |
| for methname in dir(ShlexTest): | |
| if methname.startswith("test") and methname != "testCompat": | |
| delattr(ShlexTest, methname) | |
| if __name__ == "__main__": | |
| unittest.main() |