def test_contents_good_str(ctest):
    """
    Calling contents on a file that exists as a string
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath)
    assert result == ctest.exp

def test_contents_good_list(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list')
    assert result == ctest.exp.split('\n')

def test_nodoc():
    """
    Report routines missing a doc string
    """
    pytest.dbgfunc()

    # get our bearings -- where is hpssic?
    hpssic_dir = U.dirname(sys.modules['hpssic'].__file__)

    excludes = ['setup.py', '__init__.py']

    # up a level from there, do we have a '.git' directory? That is, are we in
    # a git repository? If so, we want to talk the whole repo for .py files
    hpssic_par = U.dirname(hpssic_dir)
    if not os.path.isdir(U.pathjoin(hpssic_par, ".git")):
        # otherwise, we just work from hpssic down
        wroot = hpssic_dir
    else:
        wroot = hpssic_par

    # collect all the .py files in pylist
    pylist = []
    for r, dlist, flist in os.walk(wroot):
        if '.git' in dlist:
            dlist.remove('.git')
        pylist.extend([U.pathjoin(r, x)
                       for x in flist
                       if x.endswith('.py') and x not in excludes])

    # make a list of the modules implied in pylist in mdict. Each module name
    # is a key. The associated value is False until the module is checked.
    mlist = ['hpssic']
    for path in pylist:
        # Throw away the hpssic parent string, '.py' at the end, and split on
        # '/' to get a list of the module components
        mp = path.replace(hpssic_par + '/', '').replace('.py', '').split('/')

        if 1 < len(mp):
            fromlist = ['hpssic']
        else:
            fromlist = []
        mname = '.'.join(mp)
        if mname.startswith('hpssic'):
            mlist.append(mname)
        if mname not in sys.modules and mname.startswith('hpssic'):
            try:
                __import__(mname, fromlist=fromlist)

            except ImportError:
                pytest.fail('Failure trying to import %s' % mname)

    result = ''
    for m in mlist:
        result += nodoc_check(sys.modules[m], pylist, 0, 't')

    # result = nodoc_check(hpssic, 0, 't')
    if result != '':
        result = "The following functions need doc strings:\n" + result
        pytest.fail(result)

def test_run_fail():
    """
    Run a binary that doesn't exist
    """
    pytest.dbgfunc()
    r = tbx.run("nosuchbinary")
    assert "ERR:" in r
    assert "No such file or directory" in r

def test_run_stderr():
    """
    Run a process and capture stdout
    """
    pytest.dbgfunc()
    r = tbx.run("ls --nosuch")
    assert "ERR:" in r
    assert re.findall("(illegal|unrecognized) option", r)

def test_contents_badfmt(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    with pytest.raises(tbx.Error) as err:
        _ = tbx.contents(ctest.data.strpath, fmt='str', sep=r'\s')
    assert 'Non-default separator is only valid for list format' in str(err)

def test_contents_default(tmpdir):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath + "_nonesuch", default="take this instead")
    assert "take this instead" in c

def test_contents_str(tmpdir):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath)
    assert c == ''.join([x + '\n' for x in pt['td']])

def test_contents_list(tmpdir, contents_setup):
    """
    Test getting the contents of a file
    """
    pytest.dbgfunc()
    pt = pytest.this
    c = tbx.contents(pt['tfn'].strpath, type=list)
    assert c == [x + '\n' for x in pt['td']]

def test_grep(rgx, idx, grep_prep):
    """
    Check the results of calling U.grep()
    """
    pytest.dbgfunc()
    f = test_grep
    for n, s in enumerate(f.searches):
        assert U.grep(s, f.testdata, regex=rgx, index=idx) == f.exp[n]

def test_run_cmd_istr(rdata):
    """
    tbx.run(cmd, input=str)
    """
    pytest.dbgfunc()
    result = tbx.run('python', input='import this\n')
    for item in rdata.exp:
        assert item in result

def test_run_cmd_istrio(rdata):
    """
    tbx.run(cmd, input=StringIO)
    """
    pytest.dbgfunc()
    result = tbx.run('python', input=StringIO.StringIO('import this\n'))
    for item in rdata.exp:
        assert item in result

def test_run_stdout():
    """
    Run a process and capture stdout
    """
    pytest.dbgfunc()
    r = tbx.run('python -c "import this"')
    assert "Zen of Python" in r
    assert "Namespaces" in r

def test_contents_good_altsep(ctest):
    """
    Calling contents on a file that exists as a list
    """
    pytest.dbgfunc()
    result = tbx.contents(ctest.data.strpath, fmt='list', sep=r'\s')
    assert len(result) == len(re.split(r'\s', ctest.exp))
    assert result == re.split(r'\s', ctest.exp)

def test_run_cmd(rdata):
    """
    With just a command (*cmd*), tbx.run() should run the command and return
    its stdout + stderr
    """
    pytest.dbgfunc()
    result = tbx.run("python -c 'import this'")
    for item in rdata.exp:
        assert item in result

def test_run_noargs():
    """
    Without arguments, tbx.run() should throw a TypeError exception
    """
    pytest.dbgfunc()
    with pytest.raises(TypeError) as err:
        tbx.run()
    assert 'run() takes' in str(err)
    assert 'argument' in str(err)

def test_dispatch_help_nosuch():
    """
    Dispatch help on a function that does not exist
    """
    pytest.dbgfunc()
    exp = 'Module test.test_tbx has no attribute foo_nosuch'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch(__name__, 'foo', ['help', 'nosuch'])
    assert exp in str(err)

def test_dispatch_help_nopfx():
    """
    Dispatch help with no prefix
    """
    pytest.dbgfunc()
    exp = '*prefix* is required'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch(__name__, args=['help', 'nosuch'])
    assert exp in str(err)

def test_dispatch_help_nomodule():
    """
    Dispatch help on a non-existent module
    """
    pytest.dbgfunc()
    exp = 'Module xtest.test_tbx is not in sys.modules'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch('x' + __name__, 'foo', ['help', 'nosuch'])
    assert exp in str(err)

def test_dispatch_help_nodoc():
    """
    Dispatch help on a function that has no doc string
    """
    pytest.dbgfunc()
    exp = 'Function xtst_undocumented is missing a __doc__ string'
    with pytest.raises(SystemExit) as err:
        tbx.dispatch_help(__name__, 'xtst', ['undocumented'])
    assert exp in str(err)