import contextlib

from collections import namedtuple, deque

import datetime

from decimal import Decimal

from functools import partial

import gc

import inspect

import io

from itertools import product

import platform

import re

import sys

from types import SimpleNamespace

import unittest.mock

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 import rc_context, patheffects

import matplotlib.colors as mcolors

import matplotlib.dates as mdates

from matplotlib.container import BarContainer

from matplotlib.figure import Figure

from matplotlib.axes import Axes

from matplotlib.lines import Line2D

from matplotlib.collections import PathCollection

import matplotlib.font_manager as mfont_manager

import matplotlib.markers as mmarkers

import matplotlib.patches as mpatches

import matplotlib.path as mpath

from matplotlib.projections.geo import HammerAxes

from matplotlib.projections.polar import PolarAxes

import matplotlib.pyplot as plt

import matplotlib.text as mtext

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

import mpl_toolkits.axisartist as AA # type: ignore[import]

from numpy.testing import (

assert_allclose, assert_array_equal, assert_array_almost_equal)

from matplotlib.testing.decorators import (

image_comparison, check_figures_equal, remove_ticks_and_titles)

from matplotlib.testing._markers import needs_usetex

# 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.

@check_figures_equal()

def test_invisible_axes(fig_test, fig_ref):

ax = fig_test.subplots()

ax.set_visible(False)

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'

def test_repr():

fig, ax = plt.subplots()

ax.set_label('label')

ax.set_title('title')

ax.set_xlabel('x')

ax.set_ylabel('y')

assert repr(ax) == (

"<Axes: "

"label='label', title={'center': 'title'}, xlabel='x', ylabel='y'>")

@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')

def test_label_shift():

fig, ax = plt.subplots()

# Test label re-centering on x-axis

ax.set_xlabel("Test label", loc="left")

ax.set_xlabel("Test label", loc="center")

assert ax.xaxis.label.get_horizontalalignment() == "center"

ax.set_xlabel("Test label", loc="right")

assert ax.xaxis.label.get_horizontalalignment() == "right"

ax.set_xlabel("Test label", loc="center")

assert ax.xaxis.label.get_horizontalalignment() == "center"

# Test label re-centering on y-axis

ax.set_ylabel("Test label", loc="top")

ax.set_ylabel("Test label", loc="center")

assert ax.yaxis.label.get_horizontalalignment() == "center"

ax.set_ylabel("Test label", loc="bottom")

assert ax.yaxis.label.get_horizontalalignment() == "left"

ax.set_ylabel("Test label", loc="center")

assert ax.yaxis.label.get_horizontalalignment() == "center"

@check_figures_equal()

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()

def test_acorr_integers(fig_test, fig_ref):

np.random.seed(19680801)

Nx = 51

x = (np.random.rand(Nx) * 10).cumsum()

x = (np.ceil(x)).astype(np.int64)

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()

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()

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([f'formatter_ticker_{i:03d}.png' for i in range(1, 6)], style='mpl20',

tol=0.03 if sys.platform == 'darwin' else 0)

def test_formatter_ticker():

import matplotlib.testing.jpl_units as units

units.register()

# This should not 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.png"], style='mpl20')

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.margins(0)

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'))

def test_twin_units(twin):

axis_name = f'{twin}axis'

twin_func = f'twin{twin}'

a = ['0', '1']

b = ['a', 'b']

fig = Figure()

ax1 = fig.subplots()

ax1.plot(a, b)

assert getattr(ax1, axis_name).units is not None

ax2 = getattr(ax1, twin_func)()

assert getattr(ax2, axis_name).units is not None

assert getattr(ax2, axis_name).units is getattr(ax1, axis_name).units

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

@check_figures_equal(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'], style='_classic_test',

tol=0 if platform.machine() == 'x86_64' else 0.009)

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()

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

def test_twin_respects_position_after_set_position(twin):

fig, ax = plt.subplots()

ax.set_position([0.2, 0.2, 0.5, 0.5])

ax2 = getattr(ax, f"twin{twin}")()

assert_allclose(ax.get_position(original=True).bounds,

ax2.get_position(original=True).bounds)

assert_allclose(ax.get_position(original=False).bounds,

ax2.get_position(original=False).bounds)

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

def test_twin_keeps_layout_participation_for_layout_managed_axes(twin):

fig, ax = plt.subplots()

ax2 = getattr(ax, f"twin{twin}")()

assert ax.get_in_layout()

assert ax2.get_in_layout()

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

def test_twin_stays_aligned_after_constrained_layout(twin):

fig, ax = plt.subplots(constrained_layout=True)

ax.set_position([0.2, 0.2, 0.5, 0.5])

ax2 = getattr(ax, f"twin{twin}")()

fig.canvas.draw()

assert_allclose(ax.get_position().bounds, ax2.get_position().bounds)

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()

for ax in fig.axes:

ax.remove()

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

# axes; clearing the leader 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 follower should not touch limits

ax0.imshow(img)

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

ax1.cla()

assert ax.yaxis_inverted()

# clean up

plt.close(fig)

def test_subclass_clear_cla():

# Ensure that subclasses of Axes call cla/clear correctly.

# Note, we cannot use mocking here as we want to be sure that the

# superclass fallback does not recurse.

with pytest.warns(PendingDeprecationWarning,

match='Overriding `Axes.cla`'):

class ClaAxes(Axes):

def cla(self):

nonlocal called

called = True

with pytest.warns(PendingDeprecationWarning,

match='Overriding `Axes.cla`'):

class ClaSuperAxes(Axes):

def cla(self):

nonlocal called

called = True

super().cla()

class SubClaAxes(ClaAxes):

pass

class ClearAxes(Axes):

def clear(self):

nonlocal called

called = True

class ClearSuperAxes(Axes):

def clear(self):

nonlocal called

called = True

super().clear()

class SubClearAxes(ClearAxes):

pass

fig = Figure()

for axes_class in [ClaAxes, ClaSuperAxes, SubClaAxes,

ClearAxes, ClearSuperAxes, SubClearAxes]:

called = False

ax = axes_class(fig, [0, 0, 1, 1])

# Axes.__init__ has already called clear (which aliases to cla or is in

# the subclass).

assert called

called = False

ax.cla()

assert called

def test_cla_not_redefined_internally():

for klass in Axes.__subclasses__():

# Check that cla does not get redefined in our Axes subclasses, except

# for in the above test function.

if 'test_subclass_clear_cla' not in klass.__qualname__:

assert 'cla' not in klass.__dict__

@check_figures_equal()

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.png"], remove_text=True, style='_classic_test')

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])

@mpl.style.context('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))

# Check that autoscale is on

assert ax.get_autoscalex_on()

assert ax.get_autoscaley_on()

assert ax.get_autoscale_on()

# Set enable to None

ax.autoscale(enable=None)

# Same limits

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

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

# autoscale still on

assert ax.get_autoscalex_on()

assert ax.get_autoscaley_on()

assert ax.get_autoscale_on()

@mpl.style.context('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]))

@mpl.style.context('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()

def test_sticky_shared_axes(fig_test, fig_ref):

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

# "leader" 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(['sticky_tolerance.png'], remove_text=True, style="mpl20")

def test_sticky_tolerance():

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

width = .1

axs.flat[0].bar(x=0, height=width, bottom=20000.6)

axs.flat[0].bar(x=1, height=width, bottom=20000.1)

axs.flat[1].bar(x=0, height=-width, bottom=20000.6)

axs.flat[1].bar(x=1, height=-width, bottom=20000.1)

axs.flat[2].barh(y=0, width=-width, left=-20000.6)

axs.flat[2].barh(y=1, width=-width, left=-20000.1)

axs.flat[3].barh(y=0, width=width, left=-20000.6)

axs.flat[3].barh(y=1, width=width, left=-20000.1)

@image_comparison(['sticky_tolerance_cf.png'], remove_text=True, style="mpl20")

def test_sticky_tolerance_contourf():

fig, ax = plt.subplots()

x = y = [14496.71, 14496.75]

data = [[0, 1], [2, 3]]

ax.contourf(x, y, data)

def test_nargs_stem():

with pytest.raises(TypeError, match='0 were given'):

# stem() takes 1-3 arguments.

plt.stem()

def test_nargs_legend():

with pytest.raises(TypeError, match='3 were given'):

ax = plt.subplot()

# legend() takes 0-2 arguments.

ax.legend(['First'], ['Second'], 3)

def test_nargs_pcolorfast():

with pytest.raises(TypeError, match='2 were given'):

ax = plt.subplot()

# pcolorfast() takes 1 or 3 arguments,

# not passing any arguments fails at C = args[-1]

# before nargs_err is raised.

ax.pcolorfast([(0, 1), (0, 2)], [[1, 2, 3], [1, 2, 3]])

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

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')

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

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

def test_annotate_signature():

"""Check that the signature of Axes.annotate() matches Annotation."""

fig, ax = plt.subplots()

annotate_params = inspect.signature(ax.annotate).parameters

annotation_params = inspect.signature(mtext.Annotation).parameters

assert list(annotate_params.keys()) == list(annotation_params.keys())

for p1, p2 in zip(annotate_params.values(), annotation_params.values()):

assert p1 == p2

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

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')

@check_figures_equal()

def test_errorbar_dashes(fig_test, fig_ref):

x = [1, 2, 3, 4]

y = np.sin(x)

ax_ref = fig_ref.gca()

ax_test = fig_test.gca()

line, *_ = ax_ref.errorbar(x, y, xerr=np.abs(y), yerr=np.abs(y))

line.set_dashes([2, 2])

ax_test.errorbar(x, y, xerr=np.abs(y), yerr=np.abs(y), dashes=[2, 2])

def test_errorbar_mapview_kwarg():

D = {ii: ii for ii in range(10)}

fig, ax = plt.subplots()

ax.errorbar(x=D.keys(), y=D.values(), xerr=D.values())

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

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)

@check_figures_equal()

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.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.png'], style='mpl20')

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, 21))

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

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.png'], style='mpl20')

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, 21))

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

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)