from collections import namedtuple

import datetime

from decimal import Decimal

import io

from itertools import product

import platform

from types import SimpleNamespace

try:

from contextlib import nullcontext

except ImportError:

from contextlib import ExitStack as nullcontext # Py3.6.

import dateutil.tz

import numpy as np

from numpy import ma

from cycler import cycler

import pytest

import matplotlib

import matplotlib as mpl

from matplotlib.testing.decorators import (

image_comparison, check_figures_equal, remove_ticks_and_titles)

import matplotlib.colors as mcolors

import matplotlib.dates as mdates

from matplotlib.figure import Figure

import matplotlib.font_manager as mfont_manager

import matplotlib.markers as mmarkers

import matplotlib.patches as mpatches

import matplotlib.pyplot as plt

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

from numpy.testing import (

assert_allclose, assert_array_equal, assert_array_almost_equal)

from matplotlib import rc_context

from matplotlib.cbook import MatplotlibDeprecationWarning

# Note: Some test cases are run twice: once normally and once with labeled data

# These two must be defined in the same test function or need to have

# different baseline images to prevent race conditions when pytest runs

# the tests with multiple threads.

def test_get_labels():

fig, ax = plt.subplots()

ax.set_xlabel('x label')

ax.set_ylabel('y label')

assert ax.get_xlabel() == 'x label'

assert ax.get_ylabel() == 'y label'

@check_figures_equal()

def test_label_loc_vertical(fig_test, fig_ref):

ax = fig_test.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label', loc='top')

ax.set_xlabel('X Label', loc='right')

cbar = fig_test.colorbar(sc)

cbar.set_label("Z Label", loc='top')

ax = fig_ref.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label', y=1, ha='right')

ax.set_xlabel('X Label', x=1, ha='right')

cbar = fig_ref.colorbar(sc)

cbar.set_label("Z Label", y=1, ha='right')

@check_figures_equal()

def test_label_loc_horizontal(fig_test, fig_ref):

ax = fig_test.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label', loc='bottom')

ax.set_xlabel('X Label', loc='left')

cbar = fig_test.colorbar(sc, orientation='horizontal')

cbar.set_label("Z Label", loc='left')

ax = fig_ref.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label', y=0, ha='left')

ax.set_xlabel('X Label', x=0, ha='left')

cbar = fig_ref.colorbar(sc, orientation='horizontal')

cbar.set_label("Z Label", x=0, ha='left')

@check_figures_equal()

def test_label_loc_rc(fig_test, fig_ref):

with matplotlib.rc_context({"xaxis.labellocation": "right",

"yaxis.labellocation": "top"}):

ax = fig_test.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label')

ax.set_xlabel('X Label')

cbar = fig_test.colorbar(sc, orientation='horizontal')

cbar.set_label("Z Label")

ax = fig_ref.subplots()

sc = ax.scatter([1, 2], [1, 2], c=[1, 2], label='scatter')

ax.legend()

ax.set_ylabel('Y Label', y=1, ha='right')

ax.set_xlabel('X Label', x=1, ha='right')

cbar = fig_ref.colorbar(sc, orientation='horizontal')

cbar.set_label("Z Label", x=1, ha='right')

@check_figures_equal(extensions=["png"])

def test_acorr(fig_test, fig_ref):

np.random.seed(19680801)

Nx = 512

x = np.random.normal(0, 1, Nx).cumsum()

maxlags = Nx-1

ax_test = fig_test.subplots()

ax_test.acorr(x, maxlags=maxlags)

ax_ref = fig_ref.subplots()

# Normalized autocorrelation

norm_auto_corr = np.correlate(x, x, mode="full")/np.dot(x, x)

lags = np.arange(-maxlags, maxlags+1)

norm_auto_corr = norm_auto_corr[Nx-1-maxlags:Nx+maxlags]

ax_ref.vlines(lags, [0], norm_auto_corr)

ax_ref.axhline(y=0, xmin=0, xmax=1)

@check_figures_equal(extensions=["png"])

def test_spy(fig_test, fig_ref):

np.random.seed(19680801)

a = np.ones(32 * 32)

a[:16 * 32] = 0

np.random.shuffle(a)

a = a.reshape((32, 32))

axs_test = fig_test.subplots(2)

axs_test[0].spy(a)

axs_test[1].spy(a, marker=".", origin="lower")

axs_ref = fig_ref.subplots(2)

axs_ref[0].imshow(a, cmap="gray_r", interpolation="nearest")

axs_ref[0].xaxis.tick_top()

axs_ref[1].plot(*np.nonzero(a)[::-1], ".", markersize=10)

axs_ref[1].set(

aspect=1, xlim=axs_ref[0].get_xlim(), ylim=axs_ref[0].get_ylim()[::-1])

for ax in axs_ref:

ax.xaxis.set_ticks_position("both")

def test_spy_invalid_kwargs():

fig, ax = plt.subplots()

for unsupported_kw in [{'interpolation': 'nearest'},

{'marker': 'o', 'linestyle': 'solid'}]:

with pytest.raises(TypeError):

ax.spy(np.eye(3, 3), **unsupported_kw)

@check_figures_equal(extensions=["png"])

def test_matshow(fig_test, fig_ref):

mpl.style.use("mpl20")

a = np.random.rand(32, 32)

fig_test.add_subplot().matshow(a)

ax_ref = fig_ref.add_subplot()

ax_ref.imshow(a)

ax_ref.xaxis.tick_top()

ax_ref.xaxis.set_ticks_position('both')

@image_comparison(['formatter_ticker_001',

'formatter_ticker_002',

'formatter_ticker_003',

'formatter_ticker_004',

'formatter_ticker_005',

])

def test_formatter_ticker():

import matplotlib.testing.jpl_units as units

units.register()

# This should affect the tick size. (Tests issue #543)

matplotlib.rcParams['lines.markeredgewidth'] = 30

# This essentially test to see if user specified labels get overwritten

# by the auto labeler functionality of the axes.

xdata = [x*units.sec for x in range(10)]

ydata1 = [(1.5*y - 0.5)*units.km for y in range(10)]

ydata2 = [(1.75*y - 1.0)*units.km for y in range(10)]

ax = plt.figure().subplots()

ax.set_xlabel("x-label 001")

ax = plt.figure().subplots()

ax.set_xlabel("x-label 001")

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax = plt.figure().subplots()

ax.set_xlabel("x-label 001")

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.set_xlabel("x-label 003")

ax = plt.figure().subplots()

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.plot(xdata, ydata2, color='green', xunits="hour")

ax.set_xlabel("x-label 004")

# See SF bug 2846058

# https://sourceforge.net/tracker/?func=detail&aid=2846058&group_id=80706&atid=560720

ax = plt.figure().subplots()

ax.plot(xdata, ydata1, color='blue', xunits="sec")

ax.plot(xdata, ydata2, color='green', xunits="hour")

ax.set_xlabel("x-label 005")

ax.autoscale_view()

def test_funcformatter_auto_formatter():

def _formfunc(x, pos):

return ''

ax = plt.figure().subplots()

assert ax.xaxis.isDefault_majfmt

assert ax.xaxis.isDefault_minfmt

assert ax.yaxis.isDefault_majfmt

assert ax.yaxis.isDefault_minfmt

ax.xaxis.set_major_formatter(_formfunc)

assert not ax.xaxis.isDefault_majfmt

assert ax.xaxis.isDefault_minfmt

assert ax.yaxis.isDefault_majfmt

assert ax.yaxis.isDefault_minfmt

targ_funcformatter = mticker.FuncFormatter(_formfunc)

assert isinstance(ax.xaxis.get_major_formatter(),

mticker.FuncFormatter)

assert ax.xaxis.get_major_formatter().func == targ_funcformatter.func

def test_strmethodformatter_auto_formatter():

formstr = '{x}_{pos}'

ax = plt.figure().subplots()

assert ax.xaxis.isDefault_majfmt

assert ax.xaxis.isDefault_minfmt

assert ax.yaxis.isDefault_majfmt

assert ax.yaxis.isDefault_minfmt

ax.yaxis.set_minor_formatter(formstr)

assert ax.xaxis.isDefault_majfmt

assert ax.xaxis.isDefault_minfmt

assert ax.yaxis.isDefault_majfmt

assert not ax.yaxis.isDefault_minfmt

targ_strformatter = mticker.StrMethodFormatter(formstr)

assert isinstance(ax.yaxis.get_minor_formatter(),

mticker.StrMethodFormatter)

assert ax.yaxis.get_minor_formatter().fmt == targ_strformatter.fmt

@image_comparison(["twin_axis_locators_formatters"])

def test_twin_axis_locators_formatters():

vals = np.linspace(0, 1, num=5, endpoint=True)

locs = np.sin(np.pi * vals / 2.0)

majl = plt.FixedLocator(locs)

minl = plt.FixedLocator([0.1, 0.2, 0.3])

fig = plt.figure()

ax1 = fig.add_subplot(1, 1, 1)

ax1.plot([0.1, 100], [0, 1])

ax1.yaxis.set_major_locator(majl)

ax1.yaxis.set_minor_locator(minl)

ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%08.2lf'))

ax1.yaxis.set_minor_formatter(plt.FixedFormatter(['tricks', 'mind',

'jedi']))

ax1.xaxis.set_major_locator(plt.LinearLocator())

ax1.xaxis.set_minor_locator(plt.FixedLocator([15, 35, 55, 75]))

ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%05.2lf'))

ax1.xaxis.set_minor_formatter(plt.FixedFormatter(['c', '3', 'p', 'o']))

ax1.twiny()

ax1.twinx()

def test_twinx_cla():

fig, ax = plt.subplots()

ax2 = ax.twinx()

ax3 = ax2.twiny()

plt.draw()

assert not ax2.xaxis.get_visible()

assert not ax2.patch.get_visible()

ax2.cla()

ax3.cla()

assert not ax2.xaxis.get_visible()

assert not ax2.patch.get_visible()

assert ax2.yaxis.get_visible()

assert ax3.xaxis.get_visible()

assert not ax3.patch.get_visible()

assert not ax3.yaxis.get_visible()

assert ax.xaxis.get_visible()

assert ax.patch.get_visible()

assert ax.yaxis.get_visible()

@pytest.mark.parametrize('twin', ('x', 'y'))

@check_figures_equal(extensions=['png'], tol=0.19)

def test_twin_logscale(fig_test, fig_ref, twin):

twin_func = f'twin{twin}' # test twinx or twiny

set_scale = f'set_{twin}scale'

x = np.arange(1, 100)

# Change scale after twinning.

ax_test = fig_test.add_subplot(2, 1, 1)

ax_twin = getattr(ax_test, twin_func)()

getattr(ax_test, set_scale)('log')

ax_twin.plot(x, x)

# Twin after changing scale.

ax_test = fig_test.add_subplot(2, 1, 2)

getattr(ax_test, set_scale)('log')

ax_twin = getattr(ax_test, twin_func)()

ax_twin.plot(x, x)

for i in [1, 2]:

ax_ref = fig_ref.add_subplot(2, 1, i)

getattr(ax_ref, set_scale)('log')

ax_ref.plot(x, x)

# This is a hack because twinned Axes double-draw the frame.

# Remove this when that is fixed.

Path = matplotlib.path.Path

fig_ref.add_artist(

matplotlib.patches.PathPatch(

Path([[0, 0], [0, 1],

[0, 1], [1, 1],

[1, 1], [1, 0],

[1, 0], [0, 0]],

[Path.MOVETO, Path.LINETO] * 4),

transform=ax_ref.transAxes,

facecolor='none',

edgecolor=mpl.rcParams['axes.edgecolor'],

linewidth=mpl.rcParams['axes.linewidth'],

capstyle='projecting'))

remove_ticks_and_titles(fig_test)

remove_ticks_and_titles(fig_ref)

@image_comparison(['twin_autoscale.png'])

def test_twinx_axis_scales():

x = np.array([0, 0.5, 1])

y = 0.5 * x

x2 = np.array([0, 1, 2])

y2 = 2 * x2

fig = plt.figure()

ax = fig.add_axes((0, 0, 1, 1), autoscalex_on=False, autoscaley_on=False)

ax.plot(x, y, color='blue', lw=10)

ax2 = plt.twinx(ax)

ax2.plot(x2, y2, 'r--', lw=5)

ax.margins(0, 0)

ax2.margins(0, 0)

def test_twin_inherit_autoscale_setting():

fig, ax = plt.subplots()

ax_x_on = ax.twinx()

ax.set_autoscalex_on(False)

ax_x_off = ax.twinx()

assert ax_x_on.get_autoscalex_on()

assert not ax_x_off.get_autoscalex_on()

ax_y_on = ax.twiny()

ax.set_autoscaley_on(False)

ax_y_off = ax.twiny()

assert ax_y_on.get_autoscaley_on()

assert not ax_y_off.get_autoscaley_on()

def test_inverted_cla():

# GitHub PR #5450. Setting autoscale should reset

# axes to be non-inverted.

# plotting an image, then 1d graph, axis is now down

fig = plt.figure(0)

ax = fig.gca()

# 1. test that a new axis is not inverted per default

assert not ax.xaxis_inverted()

assert not ax.yaxis_inverted()

img = np.random.random((100, 100))

ax.imshow(img)

# 2. test that a image axis is inverted

assert not ax.xaxis_inverted()

assert ax.yaxis_inverted()

# 3. test that clearing and plotting a line, axes are

# not inverted

ax.cla()

x = np.linspace(0, 2*np.pi, 100)

ax.plot(x, np.cos(x))

assert not ax.xaxis_inverted()

assert not ax.yaxis_inverted()

# 4. autoscaling should not bring back axes to normal

ax.cla()

ax.imshow(img)

plt.autoscale()

assert not ax.xaxis_inverted()

assert ax.yaxis_inverted()

# 5. two shared axes. Inverting the master axis should invert the shared

# axes; clearing the master axis should bring axes in shared

# axes back to normal.

ax0 = plt.subplot(211)

ax1 = plt.subplot(212, sharey=ax0)

ax0.yaxis.set_inverted(True)

assert ax1.yaxis_inverted()

ax1.plot(x, np.cos(x))

ax0.cla()

assert not ax1.yaxis_inverted()

ax1.cla()

# 6. clearing the nonmaster should not touch limits

ax0.imshow(img)

ax1.plot(x, np.cos(x))

ax1.cla()

assert ax.yaxis_inverted()

# clean up

plt.close(fig)

@check_figures_equal(extensions=["png"])

def test_minorticks_on_rcParams_both(fig_test, fig_ref):

with matplotlib.rc_context({"xtick.minor.visible": True,

"ytick.minor.visible": True}):

ax_test = fig_test.subplots()

ax_test.plot([0, 1], [0, 1])

ax_ref = fig_ref.subplots()

ax_ref.plot([0, 1], [0, 1])

ax_ref.minorticks_on()

@image_comparison(["autoscale_tiny_range"], remove_text=True)

def test_autoscale_tiny_range():

# github pull #904

fig, axs = plt.subplots(2, 2)

for i, ax in enumerate(axs.flat):

y1 = 10**(-11 - i)

ax.plot([0, 1], [1, 1 + y1])

@pytest.mark.style('default')

def test_autoscale_tight():

fig, ax = plt.subplots(1, 1)

ax.plot([1, 2, 3, 4])

ax.autoscale(enable=True, axis='x', tight=False)

ax.autoscale(enable=True, axis='y', tight=True)

assert_allclose(ax.get_xlim(), (-0.15, 3.15))

assert_allclose(ax.get_ylim(), (1.0, 4.0))

@pytest.mark.style('default')

def test_autoscale_log_shared():

# related to github #7587

# array starts at zero to trigger _minpos handling

x = np.arange(100, dtype=float)

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.loglog(x, x)

ax2.semilogx(x, x)

ax1.autoscale(tight=True)

ax2.autoscale(tight=True)

plt.draw()

lims = (x[1], x[-1])

assert_allclose(ax1.get_xlim(), lims)

assert_allclose(ax1.get_ylim(), lims)

assert_allclose(ax2.get_xlim(), lims)

assert_allclose(ax2.get_ylim(), (x[0], x[-1]))

@pytest.mark.style('default')

def test_use_sticky_edges():

fig, ax = plt.subplots()

ax.imshow([[0, 1], [2, 3]], origin='lower')

assert_allclose(ax.get_xlim(), (-0.5, 1.5))

assert_allclose(ax.get_ylim(), (-0.5, 1.5))

ax.use_sticky_edges = False

ax.autoscale()

xlim = (-0.5 - 2 * ax._xmargin, 1.5 + 2 * ax._xmargin)

ylim = (-0.5 - 2 * ax._ymargin, 1.5 + 2 * ax._ymargin)

assert_allclose(ax.get_xlim(), xlim)

assert_allclose(ax.get_ylim(), ylim)

# Make sure it is reversible:

ax.use_sticky_edges = True

ax.autoscale()

assert_allclose(ax.get_xlim(), (-0.5, 1.5))

assert_allclose(ax.get_ylim(), (-0.5, 1.5))

@check_figures_equal(extensions=["png"])

def test_sticky_shared_axes(fig_test, fig_ref):

# Check that sticky edges work whether they are set in an axes that is a

# "master" in a share, or an axes that is a "follower".

Z = np.arange(15).reshape(3, 5)

ax0 = fig_test.add_subplot(211)

ax1 = fig_test.add_subplot(212, sharex=ax0)

ax1.pcolormesh(Z)

ax0 = fig_ref.add_subplot(212)

ax1 = fig_ref.add_subplot(211, sharex=ax0)

ax0.pcolormesh(Z)

@image_comparison(['offset_points'], remove_text=True)

def test_basic_annotate():

# Setup some data

t = np.arange(0.0, 5.0, 0.01)

s = np.cos(2.0*np.pi * t)

# Offset Points

fig = plt.figure()

ax = fig.add_subplot(autoscale_on=False, xlim=(-1, 5), ylim=(-3, 5))

line, = ax.plot(t, s, lw=3, color='purple')

ax.annotate('local max', xy=(3, 1), xycoords='data',

xytext=(3, 3), textcoords='offset points')

def test_annotate_parameter_warn():

fig, ax = plt.subplots()

with pytest.warns(MatplotlibDeprecationWarning,

match=r"The \'s\' parameter of annotate\(\) "

"has been renamed \'text\'"):

ax.annotate(s='now named text', xy=(0, 1))

@image_comparison(['arrow_simple.png'], remove_text=True)

def test_arrow_simple():

# Simple image test for ax.arrow

# kwargs that take discrete values

length_includes_head = (True, False)

shape = ('full', 'left', 'right')

head_starts_at_zero = (True, False)

# Create outer product of values

kwargs = product(length_includes_head, shape, head_starts_at_zero)

fig, axs = plt.subplots(3, 4)

for i, (ax, kwarg) in enumerate(zip(axs.flat, kwargs)):

ax.set_xlim(-2, 2)

ax.set_ylim(-2, 2)

# Unpack kwargs

(length_includes_head, shape, head_starts_at_zero) = kwarg

theta = 2 * np.pi * i / 12

# Draw arrow

ax.arrow(0, 0, np.sin(theta), np.cos(theta),

width=theta/100,

length_includes_head=length_includes_head,

shape=shape,

head_starts_at_zero=head_starts_at_zero,

head_width=theta / 10,

head_length=theta / 10)

def test_arrow_empty():

_, ax = plt.subplots()

# Create an empty FancyArrow

ax.arrow(0, 0, 0, 0, head_length=0)

def test_arrow_in_view():

_, ax = plt.subplots()

ax.arrow(1, 1, 1, 1)

assert ax.get_xlim() == (0.8, 2.2)

assert ax.get_ylim() == (0.8, 2.2)

def test_annotate_default_arrow():

# Check that we can make an annotation arrow with only default properties.

fig, ax = plt.subplots()

ann = ax.annotate("foo", (0, 1), xytext=(2, 3))

assert ann.arrow_patch is None

ann = ax.annotate("foo", (0, 1), xytext=(2, 3), arrowprops={})

assert ann.arrow_patch is not None

@image_comparison(['fill_units.png'], savefig_kwarg={'dpi': 60})

def test_fill_units():

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t = units.Epoch("ET", dt=datetime.datetime(2009, 4, 27))

value = 10.0 * units.deg

day = units.Duration("ET", 24.0 * 60.0 * 60.0)

dt = np.arange('2009-04-27', '2009-04-29', dtype='datetime64[D]')

dtn = mdates.date2num(dt)

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)

ax1.plot([t], [value], yunits='deg', color='red')

ind = [0, 0, 1, 1]

ax1.fill(dtn[ind], [0.0, 0.0, 90.0, 0.0], 'b')

ax2.plot([t], [value], yunits='deg', color='red')

ax2.fill([t, t, t + day, t + day],

[0.0, 0.0, 90.0, 0.0], 'b')

ax3.plot([t], [value], yunits='deg', color='red')

ax3.fill(dtn[ind],

[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],

'b')

ax4.plot([t], [value], yunits='deg', color='red')

ax4.fill([t, t, t + day, t + day],

[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],

facecolor="blue")

fig.autofmt_xdate()

def test_plot_format_kwarg_redundant():

with pytest.warns(UserWarning, match="marker .* redundantly defined"):

plt.plot([0], [0], 'o', marker='x')

with pytest.warns(UserWarning, match="linestyle .* redundantly defined"):

plt.plot([0], [0], '-', linestyle='--')

with pytest.warns(UserWarning, match="color .* redundantly defined"):

plt.plot([0], [0], 'r', color='blue')

# smoke-test: should not warn

plt.errorbar([0], [0], fmt='none', color='blue')

@image_comparison(['single_point', 'single_point'])

def test_single_point():

# Issue #1796: don't let lines.marker affect the grid

matplotlib.rcParams['lines.marker'] = 'o'

matplotlib.rcParams['axes.grid'] = True

fig, (ax1, ax2) = plt.subplots(2)

ax1.plot([0], [0], 'o')

ax2.plot([1], [1], 'o')

# Reuse testcase from above for a labeled data test

data = {'a': [0], 'b': [1]}

fig, (ax1, ax2) = plt.subplots(2)

ax1.plot('a', 'a', 'o', data=data)

ax2.plot('b', 'b', 'o', data=data)

@image_comparison(['single_date.png'], style='mpl20')

def test_single_date():

# use former defaults to match existing baseline image

plt.rcParams['axes.formatter.limits'] = -7, 7

dt = mdates.date2num(np.datetime64('0000-12-31'))

time1 = [721964.0]

data1 = [-65.54]

fig, ax = plt.subplots(2, 1)

ax[0].plot_date(time1 + dt, data1, 'o', color='r')

ax[1].plot(time1, data1, 'o', color='r')

@check_figures_equal(extensions=["png"])

def test_shaped_data(fig_test, fig_ref):

row = np.arange(10).reshape((1, -1))

col = np.arange(0, 100, 10).reshape((-1, 1))

axs = fig_test.subplots(2)

axs[0].plot(row) # Actually plots nothing (columns are single points).

axs[1].plot(col) # Same as plotting 1d.

axs = fig_ref.subplots(2)

# xlim from the implicit "x=0", ylim from the row datalim.

axs[0].set(xlim=(-.06, .06), ylim=(0, 9))

axs[1].plot(col.ravel())

def test_structured_data():

# support for structured data

pts = np.array([(1, 1), (2, 2)], dtype=[("ones", float), ("twos", float)])

# this should not read second name as a format and raise ValueError

axs = plt.figure().subplots(2)

axs[0].plot("ones", "twos", data=pts)

axs[1].plot("ones", "twos", "r", data=pts)

@image_comparison(['aitoff_proj'], extensions=["png"],

remove_text=True, style='mpl20')

def test_aitoff_proj():

"""

Test aitoff projection ref.:

https://github.com/matplotlib/matplotlib/pull/14451

"""

x = np.linspace(-np.pi, np.pi, 20)

y = np.linspace(-np.pi / 2, np.pi / 2, 20)

X, Y = np.meshgrid(x, y)

fig, ax = plt.subplots(figsize=(8, 4.2),

subplot_kw=dict(projection="aitoff"))

ax.grid()

ax.plot(X.flat, Y.flat, 'o', markersize=4)

@image_comparison(['axvspan_epoch'])

def test_axvspan_epoch():

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t0 = units.Epoch("ET", dt=datetime.datetime(2009, 1, 20))

tf = units.Epoch("ET", dt=datetime.datetime(2009, 1, 21))

dt = units.Duration("ET", units.day.convert("sec"))

ax = plt.gca()

ax.axvspan(t0, tf, facecolor="blue", alpha=0.25)

ax.set_xlim(t0 - 5.0*dt, tf + 5.0*dt)

@image_comparison(['axhspan_epoch'], tol=0.02)

def test_axhspan_epoch():

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

t0 = units.Epoch("ET", dt=datetime.datetime(2009, 1, 20))

tf = units.Epoch("ET", dt=datetime.datetime(2009, 1, 21))

dt = units.Duration("ET", units.day.convert("sec"))

ax = plt.gca()

ax.axhspan(t0, tf, facecolor="blue", alpha=0.25)

ax.set_ylim(t0 - 5.0*dt, tf + 5.0*dt)

@image_comparison(['hexbin_extent.png', 'hexbin_extent.png'], remove_text=True)

def test_hexbin_extent():

# this test exposes sf bug 2856228

fig, ax = plt.subplots()

data = (np.arange(2000) / 2000).reshape((2, 1000))

x, y = data

ax.hexbin(x, y, extent=[.1, .3, .6, .7])

# Reuse testcase from above for a labeled data test

data = {"x": x, "y": y}

fig, ax = plt.subplots()

ax.hexbin("x", "y", extent=[.1, .3, .6, .7], data=data)

@image_comparison(['hexbin_empty.png'], remove_text=True)

def test_hexbin_empty():

# From #3886: creating hexbin from empty dataset raises ValueError

ax = plt.gca()

ax.hexbin([], [])

def test_hexbin_pickable():

# From #1973: Test that picking a hexbin collection works

fig, ax = plt.subplots()

data = (np.arange(200) / 200).reshape((2, 100))

x, y = data

hb = ax.hexbin(x, y, extent=[.1, .3, .6, .7], picker=-1)

mouse_event = SimpleNamespace(x=400, y=300)

assert hb.contains(mouse_event)[0]

@image_comparison(['hexbin_log.png'], style='mpl20')

def test_hexbin_log():

# Issue #1636 (and also test log scaled colorbar)

# Remove this line when this test image is regenerated.

plt.rcParams['pcolormesh.snap'] = False

np.random.seed(19680801)

n = 100000

x = np.random.standard_normal(n)

y = 2.0 + 3.0 * x + 4.0 * np.random.standard_normal(n)

y = np.power(2, y * 0.5)

fig, ax = plt.subplots()

h = ax.hexbin(x, y, yscale='log', bins='log')

plt.colorbar(h)

def test_inverted_limits():

# Test gh:1553

# Calling invert_xaxis prior to plotting should not disable autoscaling

# while still maintaining the inverted direction

fig, ax = plt.subplots()

ax.invert_xaxis()

ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])

assert ax.get_xlim() == (4, -5)

assert ax.get_ylim() == (-3, 5)

plt.close()

fig, ax = plt.subplots()

ax.invert_yaxis()

ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])

assert ax.get_xlim() == (-5, 4)

assert ax.get_ylim() == (5, -3)

# Test inverting nonlinear axes.

fig, ax = plt.subplots()

ax.set_yscale("log")

ax.set_ylim(10, 1)

assert ax.get_ylim() == (10, 1)

@image_comparison(['nonfinite_limits'])

def test_nonfinite_limits():

x = np.arange(0., np.e, 0.01)

# silence divide by zero warning from log(0)

with np.errstate(divide='ignore'):

y = np.log(x)

x[len(x)//2] = np.nan

fig, ax = plt.subplots()

ax.plot(x, y)

@pytest.mark.style('default')

@pytest.mark.parametrize('plot_fun',

['scatter', 'plot', 'fill_between'])

@check_figures_equal(extensions=["png"])

def test_limits_empty_data(plot_fun, fig_test, fig_ref):

# Check that plotting empty data doesn't change autoscaling of dates

x = np.arange("2010-01-01", "2011-01-01", dtype="datetime64[D]")

ax_test = fig_test.subplots()

ax_ref = fig_ref.subplots()

getattr(ax_test, plot_fun)([], [])

for ax in [ax_test, ax_ref]:

getattr(ax, plot_fun)(x, range(len(x)), color='C0')

@image_comparison(['imshow', 'imshow'], remove_text=True, style='mpl20')

def test_imshow():

# use former defaults to match existing baseline image

matplotlib.rcParams['image.interpolation'] = 'nearest'

# Create a NxN image

N = 100

(x, y) = np.indices((N, N))

x -= N//2

y -= N//2

r = np.sqrt(x**2+y**2-x*y)

# Create a contour plot at N/4 and extract both the clip path and transform

fig, ax = plt.subplots()

ax.imshow(r)

# Reuse testcase from above for a labeled data test

data = {"r": r}

fig, ax = plt.subplots()

ax.imshow("r", data=data)

@image_comparison(['imshow_clip'], style='mpl20')

def test_imshow_clip():

# As originally reported by Gellule Xg <[email protected]>

# use former defaults to match existing baseline image

matplotlib.rcParams['image.interpolation'] = 'nearest'

# Create a NxN image

N = 100

(x, y) = np.indices((N, N))

x -= N//2

y -= N//2

r = np.sqrt(x**2+y**2-x*y)

# Create a contour plot at N/4 and extract both the clip path and transform

fig, ax = plt.subplots()

c = ax.contour(r, [N/4])

x = c.collections[0]

clip_path = x.get_paths()[0]

clip_transform = x.get_transform()

clip_path = mtransforms.TransformedPath(clip_path, clip_transform)

# Plot the image clipped by the contour

ax.imshow(r, clip_path=clip_path)

@check_figures_equal(extensions=["png"])

def test_imshow_norm_vminvmax(fig_test, fig_ref):

"""Parameters vmin, vmax should be ignored if norm is given."""

a = [[1, 2], [3, 4]]

ax = fig_ref.subplots()

ax.imshow(a, vmin=0, vmax=5)

ax = fig_test.subplots()

with pytest.warns(MatplotlibDeprecationWarning,

match="Passing parameters norm and vmin/vmax "

"simultaneously is deprecated."):

ax.imshow(a, norm=mcolors.Normalize(-10, 10), vmin=0, vmax=5)

@image_comparison(['polycollection_joinstyle'], remove_text=True)

def test_polycollection_joinstyle():

# Bug #2890979 reported by Matthew West

fig, ax = plt.subplots()

verts = np.array([[1, 1], [1, 2], [2, 2], [2, 1]])

c = mpl.collections.PolyCollection([verts], linewidths=40)

ax.add_collection(c)

ax.set_xbound(0, 3)

ax.set_ybound(0, 3)

@pytest.mark.parametrize(

'x, y1, y2', [

(np.zeros((2, 2)), 3, 3),

(np.arange(0.0, 2, 0.02), np.zeros((2, 2)), 3),

(np.arange(0.0, 2, 0.02), 3, np.zeros((2, 2)))

], ids=[

'2d_x_input',

'2d_y1_input',

'2d_y2_input'

]

)

def test_fill_between_input(x, y1, y2):

fig, ax = plt.subplots()

with pytest.raises(ValueError):

ax.fill_between(x, y1, y2)

@pytest.mark.parametrize(

'y, x1, x2', [

(np.zeros((2, 2)), 3, 3),

(np.arange(0.0, 2, 0.02), np.zeros((2, 2)), 3),

(np.arange(0.0, 2, 0.02), 3, np.zeros((2, 2)))

], ids=[

'2d_y_input',

'2d_x1_input',

'2d_x2_input'

]

)

def test_fill_betweenx_input(y, x1, x2):

fig, ax = plt.subplots()

with pytest.raises(ValueError):

ax.fill_betweenx(y, x1, x2)

@image_comparison(['fill_between_interpolate'], remove_text=True)

def test_fill_between_interpolate():

x = np.arange(0.0, 2, 0.02)

y1 = np.sin(2*np.pi*x)

y2 = 1.2*np.sin(4*np.pi*x)

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.plot(x, y1, x, y2, color='black')

ax1.fill_between(x, y1, y2, where=y2 >= y1, facecolor='white', hatch='/',

interpolate=True)

ax1.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',

interpolate=True)

# Test support for masked arrays.

y2 = np.ma.masked_greater(y2, 1.0)

# Test that plotting works for masked arrays with the first element masked

y2[0] = np.ma.masked

ax2.plot(x, y1, x, y2, color='black')

ax2.fill_between(x, y1, y2, where=y2 >= y1, facecolor='green',

interpolate=True)

ax2.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',

interpolate=True)

@image_comparison(['fill_between_interpolate_decreasing'],

style='mpl20', remove_text=True)

def test_fill_between_interpolate_decreasing():

p = np.array([724.3, 700, 655])

t = np.array([9.4, 7, 2.2])

prof = np.array([7.9, 6.6, 3.8])

fig, ax = plt.subplots(figsize=(9, 9))

ax.plot(t, p, 'tab:red')

ax.plot(prof, p, 'k')

ax.fill_betweenx(p, t, prof, where=prof < t,

facecolor='blue', interpolate=True, alpha=0.4)

ax.fill_betweenx(p, t, prof, where=prof > t,

facecolor='red', interpolate=True, alpha=0.4)