import sys

    pycompat,

from mercurial.utils import stringutil

f = open(hgrc, 'rb')

def _maybesysstr(v):

    if isinstance(v, bytes):

        return pycompat.sysstr(v)

    return pycompat.sysstr(stringutil.pprint(v))

def bprint(*args, **kwargs):

    print(*[_maybesysstr(a) for a in args],

          **{k: _maybesysstr(v) for k, v in kwargs.items()})

    # avoid awkward interleaving with ui object's output

    sys.stdout.flush()

def testui(user=b'foo', group=b'bar', tusers=(), tgroups=(),

           cuser=b'foo', cgroup=b'bar', debug=False, silent=False,

    f = open(hgrc, 'wb')

    f.write(b'\n[paths]\n')

    f.write(b'global = /some/path\n\n')

        f.write(b'[trusted]\n')

            f.write(b'users = %s\n' % b', '.join(tusers))

            f.write(b'groups = %s\n' % b', '.join(tgroups))

            return b'bar'

    kind = (b'different', b'same')

    who = (b'', b'user', b'group', b'user and the group')

        trusted = b', but we trust the ' + trusted

    bprint(b'# %s user, %s group%s' % (kind[user == cuser],

                                       kind[group == cgroup],

                                       trusted))

    u.setconfig(b'devel', b'warn-config-unknown', False, b'test')

    u.setconfig(b'devel', b'all-warnings', False, b'test')

    u.setconfig(b'ui', b'debug', pycompat.bytestr(bool(debug)))

    u.setconfig(b'ui', b'report_untrusted', pycompat.bytestr(bool(report)))

    u.readconfig(b'.hg/hgrc')

    bprint(b'trusted')

    for name, path in u.configitems(b'paths'):

        bprint(b'   ', name, b'=', util.pconvert(path))

    bprint(b'untrusted')

    for name, path in u.configitems(b'paths', untrusted=True):

        bprint(b'.', end=b' ')

        u.config(b'paths', name) # warning with debug=True

        bprint(b'.', end=b' ')

        u.config(b'paths', name, untrusted=True) # no warnings

        bprint(name, b'=', util.pconvert(path))

os.mkdir(b'repo')

os.chdir(b'repo')

os.mkdir(b'.hg')

f = open(b'.hg/hgrc', 'wb')

f.write(b'[paths]\n')

f.write(b'local = /another/path\n\n')

testui(group=b'def')

testui(user=b'abc')

testui(user=b'abc', tgroups=[b'bar'])

testui(user=b'abc', group=b'def')

testui(user=b'abc', group=b'def', tusers=[b'abc'])

testui(user=b'abc', group=b'def', tgroups=[b'def'])

testui(user=b'abc', group=b'def', tusers=[b'abc'], tgroups=[b'def'])

bprint(b'# we trust all users')

testui(user=b'abc', group=b'def', tusers=[b'*'])

bprint(b'# we trust all groups')

testui(user=b'abc', group=b'def', tgroups=[b'*'])

bprint(b'# we trust all users and groups')

testui(user=b'abc', group=b'def', tusers=[b'*'], tgroups=[b'*'])

bprint(b"# we don't get confused by users and groups with the same name")

testui(user=b'abc', group=b'def', tusers=[b'def'], tgroups=[b'abc'])

bprint(b"# list of user names")

testui(user=b'abc', group=b'def', tusers=[b'foo', b'xyz', b'abc', b'bleh'],

       tgroups=[b'bar', b'baz', b'qux'])

bprint(b"# list of group names")

testui(user=b'abc', group=b'def', tusers=[b'foo', b'xyz', b'bleh'],

       tgroups=[b'bar', b'def', b'baz', b'qux'])

bprint(b"# Can't figure out the name of the user running this process")

testui(user=b'abc', group=b'def', cuser=None)

bprint(b"# prints debug warnings")

u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True)

bprint(b"# report_untrusted enabled without debug hides warnings")

u = testui(user=b'abc', group=b'def', cuser=b'foo', report=False)

bprint(b"# report_untrusted enabled with debug shows warnings")

u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True, report=False)

bprint(b"# ui.readconfig sections")

filename = b'foobar'

f = open(filename, 'wb')

f.write(b'[foobar]\n')

f.write(b'baz = quux\n')

u.readconfig(filename, sections=[b'foobar'])

bprint(u.config(b'foobar', b'baz'))

bprint(b"# read trusted, untrusted, new ui, trusted")

u.setconfig(b'devel', b'warn-config-unknown', False, b'test')

u.setconfig(b'devel', b'all-warnings', False, b'test')

u.setconfig(b'ui', b'debug', b'on')

    return b'foo'

u2.readconfig(b'.hg/hgrc')

bprint(b'trusted:')

bprint(u2.config(b'foobar', b'baz'))

bprint(b'untrusted:')

bprint(u2.config(b'foobar', b'baz', untrusted=True))

bprint(b"# error handling")

        bprint(b'raised', inst.__class__.__name__)

        bprint(b'no exception?!')

bprint(b"# file doesn't exist")

os.unlink(b'.hg/hgrc')

assert not os.path.exists(b'.hg/hgrc')

testui(user=b'abc', group=b'def', debug=True, silent=True)

bprint(b"# parse error")

f = open(b'.hg/hgrc', 'wb')

f.write(b'foo')

    testui(user=b'abc', group=b'def', silent=True)

    bprint(inst)

    bprint(inst)

bprint(b'# access typed information')

with open(b'.hg/hgrc', 'wb') as f:

    f.write(b'''\

u = testui(user=b'abc', group=b'def', cuser=b'foo', silent=True)

bprint(b'# suboptions, trusted and untrusted')

trusted = u.configsuboptions(b'foo', b'sub')

untrusted = u.configsuboptions(b'foo', b'sub', untrusted=True)

bprint(

bprint(b'# path, trusted and untrusted')

bprint(configpath(b'foo', b'path'), configpath(b'foo', b'path', untrusted=True))

bprint(b'# bool, trusted and untrusted')

bprint(u.configbool(b'foo', b'bool'),

       u.configbool(b'foo', b'bool', untrusted=True))

bprint(b'# int, trusted and untrusted')

bprint(

    u.configint(b'foo', b'int', 0),

    u.configint(b'foo', b'int', 0, untrusted=True))

bprint(b'# bytes, trusted and untrusted')

bprint(

    u.configbytes(b'foo', b'bytes', 0),

    u.configbytes(b'foo', b'bytes', 0, untrusted=True))

bprint(b'# list, trusted and untrusted')

bprint(

    u.configlist(b'foo', b'list', []),

    u.configlist(b'foo', b'list', [], untrusted=True))