def harness(p):
psh.init(p)
header_seen = False
expected_tasks = ['[idle]', 'init', 'psh']
ps_header = 'PID PPID PR STATE %CPU WAIT TIME VMEM THR CMD'.split()
p.sendline('ps')
p.expect(r'ps(\r+)\n')
while True:
# Get prompt or new line
idx = p.expect([r'\(psh\)\% ', r'(.*?)(\r+)\n'])
if idx == 0:
break
line = p.match.group(0)
if line.split() == ps_header and not header_seen:
header_seen = True
else:
try:
pid, ppid, pr, state, cpu, wait, time, vmem, thr, task = line.split(
)
except ValueError:
assert False, f'wrong ps output: {line}'
if task in expected_tasks:
expected_tasks.remove(task)
assert header_seen, 'ps header not seen'
assert not expected_tasks, f'not seen expected task: {", ".join(expected_tasks)}'
def harness(p):
psh.init(p)
mkdir(p, 'etc')
# Create test environment
mkdir(p, 'testenv')
mkdir(p, 'testenv/ipsum')
mkdir(p, 'testenv/lorem')
mkdir(p, 'testenv/loremipsum')
touch(p, 'testenv/loremipsum/dolor.txt')
touch(p, 'testenv/loremipsum/sit.jpg')
touch(p, 'testenv/loremipsum/amet.exe')
# Check autocompletion in command
assert_completion(p, [['ls e', 'tc/']])
assert_completion(p, [['ls /e', 'tc/']])
assert_completion(p, [['ls /etc', '/']])
assert_completion(p, [['ls testen', 'v/']])
assert_completion(p, [['ls /testen', 'v/']])
assert_completion(p, [['ls testenv/i', 'psum/']])
longpath = 'ls testenv/lorem/./../lorem/../../testenv/ip'
assert_completion(p, [[longpath, 'sum']])
assert_completion(p, [['ls ../testenv/ip', 'sum']])
# Check multiple autocompletion in one
assert_completion(p, [['ls testen', 'v/'], ['loremi', 'psum/'], ['dol', 'or.txt']])
# Check hints
assert_hints(p, path='ls testenv/', hints=['ipsum', 'lorem', 'loremipsum'])
assert_hints(p, path='ls testenv/lorem/../', hints=['ipsum', 'lorem', 'loremipsum'])
assert_hints(p, path='ls testenv/loremipsum/', hints=['amet', 'dolor', 'sit'])
def harness(p):
psh.init(p)
psh.assert_prompt(p)
# Simple check
psh.assert_cmd(p, 'echo', '\r+\n', 'empty echo fail', is_regex=True)
psh.assert_cmd(p, 'echo loremipsum', 'loremipsum', 'simple text not echoed back')
psh.assert_cmd(p, 'echo lorem ipsum dolor ales', 'lorem ipsum dolor ales', 'multiple argument not echoed back')
# Return value check
psh.assert_cmd(p, 'echo $?', '0', 'last exit status was not zero')
p.sendline("exec") # force execution of bad command
psh.assert_cmd(p, 'echo $?', '-22', 'last exit status was not expected -22')
# Mingle checks
psh.assert_cmd(p, 'echo $ lorem ipsum', ' lorem ipsum', 'bad empty $ interpretation')
psh.assert_cmd(p, 'echo ? lorem', '? lorem', 'bad empty ? interpretation')
psh.assert_cmd(p, 'echo lorem $? $? ipsum $?', 'lorem 0 0 ipsum 0', 'multiple return values print fail')
psh.assert_cmd(p, 'echo lorem $ $ ipsum', 'lorem ipsum', 'echo bad $ interpretation')
psh.assert_cmd(p, 'echo lorem $ipsum dolor$ales', 'lorem dolor', 'echo bad $ interpretation')
psh.assert_cmd(p, 'echo $lorem$? ipsum', '0 ipsum', 'echo can`t print two variables consecutively')
# Eating '"' check
psh.assert_cmd(p, 'echo "lorem ipsum"', 'lorem ipsum', 'bad \'"\' eating')
psh.assert_cmd(p, 'echo "lorem ""$lorem $?"', 'lorem 0', 'bad \'"\' eating')
def harness(p):
psh.init(p)
assert_errors(p)
pid_list = create_psh_processes(p, 3)
assert_kill_procs(p, pid_list)
def harness(p):
psh.init(p)
assert_execve_env_changed(p)
assert_execve_env_unchanged(p)
assert_execve_path_searched(p)
assert_execvpe_env_changed(p)
assert_execvpe_env_unchanged(p)
assert_execvpe_path_searched(p)
assert_execvp_env_unchanged(p)
assert_execvp_path_searched(p)
def harness(p):
psh.init(p)
create_testdir(p, ROOT_TEST_DIR)
# these cases may not work on non-rootfs targets, because of too many internal directories
assert_multi(p)
assert_extralong(p)
psh_cmds = psh.get_commands(p)
assert_ls_t(p)
assert_ls_S(p)
assert_ls_pshcmds(p, psh_cmds)
def harness(p):
psh.init(p)
fname = 'etc/shells'
expected = r'# /etc/shells: valid login shells(\r+)\n/bin/sh(\r+)\n'
cmd = f'cat {fname}'
psh.assert_cmd(p,
cmd,
expected,
msg='The /etc/shells/ file content is invalid',
is_regex=True)
def harness(p):
chars = list(set(string.printable) - set(string.whitespace) - set('/'))
psh.init(p)
assert_dir_created(p, 'example_dir')
files = ls(p)
assert files == ls(p, 'example_dir/..')
assert_dir_created(p, 'example_dir/another_dir')
assert_dir_created(p, ''.join(chars))
assert_random_dirs(p, chars)
assert not mkdir(p, '/')
assert not mkdir(p, '/example_dir')
def harness(p):
listed_files = ('test1', 'test0', 'dir')
to_create_files = ('.hidden', ) + listed_files
all_files = ('.', '..') + to_create_files
psh.init(p)
create_testdir(p, ROOT_TEST_DIR)
prepare_testdir(p, to_create_files)
assert_ls_err(p)
assert_ls_noarg(p, listed_files)
assert_ls_1(p, listed_files)
assert_ls_a(p, all_files)
assert_ls_d(p)
assert_ls_f(p, listed_files)
assert_ls_h(p)
assert_ls_l(p, listed_files)
assert_ls_r(p, listed_files)
def harness(p):
chars = list(set(string.printable) - set(string.whitespace) - set('/'))
psh.init(p)
assert_dir_created(p, 'example_dir')
files = ls(p)
assert files == ls(p, 'example_dir/..')
assert_dir_created(p, 'example_dir/another_dir')
# there are some targets, where max fname length equals 64
assert_dir_created(p, ''.join(chars[:50]))
assert_dir_created(p, ''.join(chars[50:]))
assert_random_dirs(p, chars)
assert not mkdir(p, '/')
assert not mkdir(p, '/example_dir')
def harness(p):
# Run psh
psh.init(p)
# Run pshlogin
assert_pshlogin(p)
# Wrong credentials
logintools.assert_login_fail(p, cred_ok_etc.user,
cred_bad.passwd) # good login, wrong password
logintools.assert_login_fail(
p, cred_bad.user, cred_ok_etc.passwd) # bad login, good password
logintools.assert_login_fail(p, cred_bad.user,
cred_bad.passwd) # bad login, bad password
# Empty Credentials
logintools.assert_login_fail(
p, cred_ok_etc.user, cred_empty.passwd) # good login, empty password
logintools.assert_login_fail(
p, cred_bad.user, cred_empty.passwd) # bad login, empty password
logintools.assert_login_empty(
p, cred_empty.user) # empty login, good password
# Good login, new psh is created
logintools.assert_login(p, cred_ok_etc.user, cred_ok_etc.passwd)
# Exit and try to login again but with defuser:
p.send(EOT)
assert_pshlogin(p)
logintools.assert_login_fail(p, cred_ok.user, cred_bad.passwd)
logintools.assert_login(p, cred_ok.user, cred_ok.passwd)
p.send(EOT)
# Too long credentials
assert_pshlogin(p)
p.send(string.printable + '\n')
assert p.expect_exact(
['Login:'******'Long login does not repeat login procedure'
logintools.assert_login_fail(p, cred_ok.user,
string.printable) # too long password
def harness(p):
# Run psh
psh.init(p)
# Check if auth app is available and login exit
assert_auth(p)
p.send(EOT)
psh.assert_prompt(p,
msg='Cannot exit "auth" during login passing',
timeout=1)
# Exiting auth during password
assert_auth(p)
p.send(cred_bad.user + '\n')
p.send(EOT)
psh.assert_prompt(p, msg='Cannot exit "auth": password passing', timeout=1)
# Good login
assert_auth(p)
logintools.assert_login(p, cred_ok.user, cred_ok.passwd)
# Wrong credentials
assert_auth(p)
logintools.assert_login_fail(p,
cred_ok.user,
cred_bad.passwd,
expect_psh_afterwards=True)
assert_auth(p)
logintools.assert_login_fail(p,
cred_bad.user,
cred_ok.passwd,
expect_psh_afterwards=True)
assert_auth(p)
logintools.assert_login_fail(p,
cred_bad.user,
cred_bad.passwd,
expect_psh_afterwards=True)
# Empty Credentials
assert_auth(p)
logintools.assert_login_fail(p,
cred_ok.user,
cred_empty.passwd,
expect_psh_afterwards=True)
assert_auth(p)
logintools.assert_login_fail(p,
cred_bad.user,
cred_empty.passwd,
expect_psh_afterwards=True)
assert_auth(p)
logintools.assert_login_empty(p, cred_empty.user)
p.send(
EOT
) # assert_login_empty() with empty login does not go back to psh, exit needed
# Too long credentials
printables = string.printable
assert_auth(p)
p.send(printables + '\n')
assert p.expect_exact(
['Login:'******'Long login does not repeat login procedure'
logintools.assert_login_fail(p, cred_ok.user,
printables) # too long password
# Test backspace
assert_auth(p)
p.send(cred_ok.user + cred_ok.user)
for i in range(len(cred_ok.user) + 1): # Test just enough backspaces
p.send(BACKSPACE)
p.send(cred_ok.user[-1] + '\n')
assert p.expect_exact(["Password:", pexpect.TIMEOUT]) == 0
p.send(cred_ok.passwd)
for i in range(len(cred_ok.passwd) + 9): # test too many backspaces
p.send(BACKSPACE)
p.send(cred_ok.passwd + '\n')
psh.assert_prompt(p, msg='Login should pass but failed', timeout=1)
def harness(p):
psh.init(p)
# need to add more test cases when it will be possible to write content to the file
assert_cat_err(p)
assert_cat_h(p)
def harness(p):
psh.init(p)
