usetex = mpl.rcParams['text.usetex']

linewidth = mpl.rcParams['lines.linewidth']

# test context given dictionary

with mpl.rc_context(rc={'text.usetex': not usetex}):

assert mpl.rcParams['text.usetex'] == (not usetex)

assert mpl.rcParams['text.usetex'] == usetex

# test context given filename (mpl.rc sets linewdith to 33)

with mpl.rc_context(fname=fname):

assert mpl.rcParams['lines.linewidth'] == 33

assert mpl.rcParams['lines.linewidth'] == linewidth

# test context given filename and dictionary

with mpl.rc_context(fname=fname, rc={'lines.linewidth': 44}):

assert mpl.rcParams['lines.linewidth'] == 44

assert mpl.rcParams['lines.linewidth'] == linewidth

# test rc_file

try:

mpl.rc_file(fname)

assert mpl.rcParams['lines.linewidth'] == 33

finally:

rc = mpl.RcParams({'font.cursive': ['Apple Chancery',

'Textile',

'Zapf Chancery',

'cursive'],

'font.family': 'sans-serif',

'font.weight': 'normal',

'font.size': 12})

if six.PY3:

expected_repr = """

'font.weight': 'normal'})""".lstrip()

else:

expected_repr = """

u'font.weight': u'normal'})""".lstrip()

assert expected_repr == repr(rc)

if six.PY3:

expected_str = """

font.weight: normal""".lstrip()

else:

expected_str = """

font.weight: normal""".lstrip()

assert expected_str == str(rc)

# test the find_all functionality

assert ['font.cursive', 'font.size'] == sorted(rc.find_all('i[vz]'))

rc = mpl.RcParams({'figure.figsize': (3.5, 42)})

bad_dict = {'figure.figsize': (3.5, 42, 1)}

# make sure validation happens on input

with pytest.raises(ValueError):

with warnings.catch_warnings():

warnings.filterwarnings('ignore',

message='.*(validate)',

category=UserWarning)

with pytest.raises(ValueError):

with warnings.catch_warnings():

warnings.filterwarnings('ignore',

message='.*(validate)',

category=UserWarning)

# Test that it possible to add all values to itself / deepcopy

# This was not possible because validate_bool_maybe_none did not

# accept None as an argument.

# https://github.com/matplotlib/matplotlib/issues/2543

# We filter warnings at this stage since a number of them are raised

# for deprecated rcparams as they should. We dont want these in the

# printed in the test suite.

with warnings.catch_warnings():

warnings.filterwarnings('ignore',

message='.*(deprecated|obsolete)',

category=UserWarning)

with mpl.rc_context():

_copy = mpl.rcParams.copy()

for key in _copy:

mpl.rcParams[key] = _copy[key]

mpl.rcParams['text.dvipnghack'] = None

with mpl.rc_context():

from copy import deepcopy

_deep_copy = deepcopy(mpl.rcParams)

# real test is that this does not raise

assert validate_bool_maybe_none(None) is None

assert validate_bool_maybe_none("none") is None

_fonttype = mpl.rcParams['svg.fonttype']

assert _fonttype == mpl.rcParams['svg.embed_char_paths']

with mpl.rc_context():

mpl.rcParams['svg.embed_char_paths'] = False

assert mpl.rcParams['svg.fonttype'] == "none"

with pytest.raises(ValueError):

validate_bool_maybe_none("blah")

with pytest.raises(ValueError):

validate_bool(None)

with pytest.raises(ValueError):

with mpl.rc_context():

('face', {'color': 'r'}, mcolors.to_rgba('r')),

('face', {'color': 'inherit', 'axes.facecolor': 'r'},

mcolors.to_rgba('r')),

('face', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g')),

('edge', {'color': 'r'}, mcolors.to_rgba('r')),

('edge', {'color': 'inherit', 'axes.edgecolor': 'r'},

mcolors.to_rgba('r')),

('edge', {'color': 'g', 'axes.facecolor': 'r'}, mcolors.to_rgba('g'))

'same facecolor',

'inherited facecolor',

'different facecolor',

'same edgecolor',

'inherited edgecolor',

'different facecolor',

param_dict['legend.%scolor' % (color_type, )] = param_dict.pop('color')

get_func = 'get_%scolor' % (color_type, )

with mpl.rc_context(param_dict):

_, ax = plt.subplots()

ax.plot(range(3), label='test')

leg = ax.legend()

utf32_be = os.path.join(os.path.dirname(__file__),

'test_utf32_be_rcparams.rc')

import locale

with mock.patch('locale.getpreferredencoding', return_value='UTF-32-BE'):

rc = mpl.rc_params_from_file(utf32_be, True, False)

validation_tests = (

{'validator': validate_bool,

'success': chain(((_, True) for _ in

('t', 'y', 'yes', 'on', 'true', '1', 1, True)),

((_, False) for _ in

('f', 'n', 'no', 'off', 'false', '0', 0, False))),

'fail': ((_, ValueError)

for _ in ('aardvark', 2, -1, [], ))},

{'validator': validate_stringlist,

'success': (('', []),

('a,b', ['a', 'b']),

('aardvark', ['aardvark']),

('aardvark, ', ['aardvark']),

('aardvark, ,', ['aardvark']),

(['a', 'b'], ['a', 'b']),

(('a', 'b'), ['a', 'b']),

(iter(['a', 'b']), ['a', 'b']),

(np.array(['a', 'b']), ['a', 'b']),

((1, 2), ['1', '2']),

(np.array([1, 2]), ['1', '2']),

),

'fail': ((dict(), ValueError),

(1, ValueError),

)

},

{'validator': validate_nseq_int(2),

'success': ((_, [1, 2])

for _ in ('1, 2', [1.5, 2.5], [1, 2],

(1, 2), np.array((1, 2)))),

'fail': ((_, ValueError)

for _ in ('aardvark', ('a', 1),

(1, 2, 3)

))

},

{'validator': validate_nseq_float(2),

'success': ((_, [1.5, 2.5])

for _ in ('1.5, 2.5', [1.5, 2.5], [1.5, 2.5],

(1.5, 2.5), np.array((1.5, 2.5)))),

'fail': ((_, ValueError)

for _ in ('aardvark', ('a', 1),

(1, 2, 3)

))

},

{'validator': validate_cycler,

'success': (('cycler("color", "rgb")',

cycler("color", 'rgb')),

(cycler('linestyle', ['-', '--']),

cycler('linestyle', ['-', '--'])),

("""(cycler("color", ["r", "g", "b"]) +

cycler("mew", [2, 3, 5]))""",

(cycler("color", 'rgb') +

cycler("markeredgewidth", [2, 3, 5]))),

("cycler(c='rgb', lw=[1, 2, 3])",

cycler('color', 'rgb') + cycler('linewidth', [1, 2, 3])),

("cycler('c', 'rgb') * cycler('linestyle', ['-', '--'])",

(cycler('color', 'rgb') *

cycler('linestyle', ['-', '--']))),

(cycler('ls', ['-', '--']),

cycler('linestyle', ['-', '--'])),

(cycler(mew=[2, 5]),

cycler('markeredgewidth', [2, 5])),

),

# This is *so* incredibly important: validate_cycler() eval's

# an arbitrary string! I think I have it locked down enough,

# and that is what this is testing.

# TODO: Note that these tests are actually insufficient, as it may

# be that they raised errors, but still did an action prior to

# raising the exception. We should devise some additional tests

# for that...

'fail': ((4, ValueError), # Gotta be a string or Cycler object

('cycler("bleh, [])', ValueError), # syntax error

('Cycler("linewidth", [1, 2, 3])',

ValueError), # only 'cycler()' function is allowed

('1 + 2', ValueError), # doesn't produce a Cycler object

('os.system("echo Gotcha")', ValueError), # os not available

('import os', ValueError), # should not be able to import

('def badjuju(a): return a; badjuju(cycler("color", "rgb"))',

ValueError), # Should not be able to define anything

# even if it does return a cycler

('cycler("waka", [1, 2, 3])', ValueError), # not a property

('cycler(c=[1, 2, 3])', ValueError), # invalid values

("cycler(lw=['a', 'b', 'c'])", ValueError), # invalid values

(cycler('waka', [1, 3, 5]), ValueError), # not a property

(cycler('color', ['C1', 'r', 'g']), ValueError) # no CN

)

},

{'validator': validate_hatch,

'success': (('--|', '--|'), ('\\oO', '\\oO'),

('/+*/.x', '/+*/.x'), ('', '')),

'fail': (('--_', ValueError),

(8, ValueError),

('X', ValueError)),

},

{'validator': validate_colorlist,

'success': (('r,g,b', ['r', 'g', 'b']),

(['r', 'g', 'b'], ['r', 'g', 'b']),

('r, ,', ['r']),

(['', 'g', 'blue'], ['g', 'blue']),

([np.array([1, 0, 0]), np.array([0, 1, 0])],

np.array([[1, 0, 0], [0, 1, 0]])),

(np.array([[1, 0, 0], [0, 1, 0]]),

np.array([[1, 0, 0], [0, 1, 0]])),

),

'fail': (('fish', ValueError),

),

},

{'validator': validate_hist_bins,

'success': (('auto', 'auto'),

('10', 10),

('1, 2, 3', [1, 2, 3]),

([1, 2, 3], [1, 2, 3]),

(np.arange(15), np.arange(15))

),

'fail': (('aardvark', ValueError),

)

}

)

# The behavior of _validate_linestyle depends on the version of Python.

# ASCII-compliant bytes arguments should pass on Python 2 because of the

# automatic conversion between bytes and strings. Python 3 does not

# perform such a conversion, so the same cases should raise an exception.

#

# Common cases:

ls_test = {'validator': _validate_linestyle,

'success': (('-', '-'), ('solid', 'solid'),

('--', '--'), ('dashed', 'dashed'),

('-.', '-.'), ('dashdot', 'dashdot'),

(':', ':'), ('dotted', 'dotted'),

('', ''), (' ', ' '),

('None', 'none'), ('none', 'none'),

('DoTtEd', 'dotted'), # case-insensitive

(['1.23', '4.56'], (None, [1.23, 4.56])),

([1.23, 456], (None, [1.23, 456.0])),

([1, 2, 3, 4], (None, [1.0, 2.0, 3.0, 4.0])),

),

'fail': (('aardvark', ValueError), # not a valid string

('dotted'.encode('utf-16'), ValueError), # even on PY2

((None, [1, 2]), ValueError), # (offset, dashes) != OK

((0, [1, 2]), ValueError), # idem

((-1, [1, 2]), ValueError), # idem

([1, 2, 3], ValueError), # sequence with odd length

(1.23, ValueError), # not a sequence

)

}

# Add some cases of bytes arguments that Python 2 can convert silently:

ls_bytes_args = (b'dotted', 'dotted'.encode('ascii'))

if six.PY3:

ls_test['fail'] += tuple((arg, ValueError) for arg in ls_bytes_args)

else:

ls_test['success'] += tuple((arg, 'dotted') for arg in ls_bytes_args)

# Update the validation test sequence.

validation_tests += (ls_test,)

for validator_dict in validation_tests:

validator = validator_dict['validator']

if valid:

for arg, target in validator_dict['success']:

yield validator, arg, target

else:

for arg, error_type in validator_dict['fail']:

res = validator(arg)

if isinstance(target, np.ndarray):

assert np.all(res == target)

elif not isinstance(target, Cycler):

assert res == target

else:

# Cyclers can't simply be asserted equal. They don't implement __eq__

# There was previously a bug that meant that if rc_context failed and

# raised an exception due to issues in the supplied rc parameters, the

# global rc parameters were left in a modified state.

with mpl.rc_context(rc={'text.usetex': False}):

assert mpl.rcParams['text.usetex'] is False

with pytest.raises(KeyError):

with mpl.rc_context(rc=OrderedDict([('text.usetex', True),('test.blah', True)])):

pass