from collections import namedtuple

from itertools import product

from distutils.version import LooseVersion

import io

import platform

import datetime

import dateutil.tz as dutz

import numpy as np

from numpy import ma

from cycler import cycler

from decimal import Decimal

import pytest

import warnings

import matplotlib

import matplotlib as mpl

from matplotlib.testing.decorators import (

image_comparison, check_figures_equal, remove_ticks_and_titles)

import matplotlib.pyplot as plt

import matplotlib.markers as mmarkers

import matplotlib.patches as mpatches

import matplotlib.colors as mcolors

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 (

IgnoredKeywordWarning, 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'

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

def test_acorr():

# Remove this line when this test image is regenerated.

plt.rcParams['text.kerning_factor'] = 6

np.random.seed(19680801)

n = 512

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

fig, ax = plt.subplots()

ax.acorr(x, maxlags=n - 1, label='acorr')

ax.legend()

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

def test_spy():

np.random.seed(19680801)

a = np.ones(32 * 32)

a[:16 * 32] = 0

np.random.shuffle(a)

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

fig, ax = plt.subplots()

ax.spy(a)

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)

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

def test_matshow():

np.random.seed(19680801)

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

fig, ax = plt.subplots()

ax.matshow(a)

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

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

@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(111, 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)

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_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(['polar_axes'], style='default')

def test_polar_annotations():

# you can specify the xypoint and the xytext in different

# positions and coordinate systems, and optionally turn on a

# connecting line and mark the point with a marker. Annotations

# work on polar axes too. In the example below, the xy point is

# in native coordinates (xycoords defaults to 'data'). For a

# polar axes, this is in (theta, radius) space. The text in this

# example is placed in the fractional figure coordinate system.

# Text keyword args like horizontal and vertical alignment are

# respected

# Setup some data

r = np.arange(0.0, 1.0, 0.001)

theta = 2.0 * 2.0 * np.pi * r

fig = plt.figure()

ax = fig.add_subplot(111, polar=True)

line, = ax.plot(theta, r, color='#ee8d18', lw=3)

line, = ax.plot((0, 0), (0, 1), color="#0000ff", lw=1)

ind = 800

thisr, thistheta = r[ind], theta[ind]

ax.plot([thistheta], [thisr], 'o')

ax.annotate('a polar annotation',

xy=(thistheta, thisr), # theta, radius

xytext=(0.05, 0.05), # fraction, fraction

textcoords='figure fraction',

arrowprops=dict(facecolor='black', shrink=0.05),

horizontalalignment='left',

verticalalignment='baseline',

)

ax.tick_params(axis='x', tick1On=True, tick2On=True, direction='out')

@image_comparison(['polar_coords'], style='default', remove_text=True)

def test_polar_coord_annotations():

# You can also use polar notation on a cartesian axes. Here the

# native coordinate system ('data') is cartesian, so you need to

# specify the xycoords and textcoords as 'polar' if you want to

# use (theta, radius)

from matplotlib.patches import Ellipse

el = Ellipse((0, 0), 10, 20, facecolor='r', alpha=0.5)

fig = plt.figure()

ax = fig.add_subplot(111, aspect='equal')

ax.add_artist(el)

el.set_clip_box(ax.bbox)

ax.annotate('the top',

xy=(np.pi/2., 10.), # theta, radius

xytext=(np.pi/3, 20.), # theta, radius

xycoords='polar',

textcoords='polar',

arrowprops=dict(facecolor='black', shrink=0.05),

horizontalalignment='left',

verticalalignment='baseline',

clip_on=True, # clip to the axes bounding box

)

ax.set_xlim(-20, 20)

ax.set_ylim(-20, 20)

@image_comparison(['polar_alignment.png'])

def test_polar_alignment():

"""

Test that changing the vertical/horizontal alignment of a polar graph

works as expected.

"""

angles = np.arange(0, 360, 90)

grid_values = [0, 0.2, 0.4, 0.6, 0.8, 1]

fig = plt.figure()

rect = [0.1, 0.1, 0.8, 0.8]

horizontal = fig.add_axes(rect, polar=True, label='horizontal')

horizontal.set_thetagrids(angles)

vertical = fig.add_axes(rect, polar=True, label='vertical')

vertical.patch.set_visible(False)

for i in range(2):

fig.axes[i].set_rgrids(

grid_values, angle=angles[i],

horizontalalignment='left', verticalalignment='top')

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

def test_fill_units():

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

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

value = 10.0 * units.deg

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

fig = plt.figure()

# Top-Left

ax1 = fig.add_subplot(221)

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

ax1.fill([733525.0, 733525.0, 733526.0, 733526.0],

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

# Top-Right

ax2 = fig.add_subplot(222)

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

# Bottom-Left

ax3 = fig.add_subplot(223)

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

ax3.fill([733525.0, 733525.0, 733526.0, 733526.0],

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

'b')

# Bottom-Right

ax4 = fig.add_subplot(224)

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

@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

plt.figure()

plt.subplot(211)

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

plt.subplot(212)

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

# Reuse testcase from above for a labeled data test

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

plt.figure()

plt.subplot(211)

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

plt.subplot(212)

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

time1 = [721964.0]

data1 = [-65.54]

plt.subplot(211)

plt.plot_date(time1, data1, 'o', color='r')

plt.subplot(212)

plt.plot(time1, data1, 'o', color='r')

@image_comparison(['shaped_data'])

def test_shaped_data():

xdata = np.array([[0.53295185, 0.23052951, 0.19057629, 0.66724975,

0.96577916, 0.73136095, 0.60823287, 0.01792100,

0.29744742, 0.27164665],

[0.27980120, 0.25814229, 0.02818193, 0.12966456,

0.57446277, 0.58167607, 0.71028245, 0.69112737,

0.89923072, 0.99072476],

[0.81218578, 0.80464528, 0.76071809, 0.85616314,

0.12757994, 0.94324936, 0.73078663, 0.09658102,

0.60703967, 0.77664978],

[0.28332265, 0.81479711, 0.86985333, 0.43797066,

0.32540082, 0.43819229, 0.92230363, 0.49414252,

0.68168256, 0.05922372],

[0.10721335, 0.93904142, 0.79163075, 0.73232848,

0.90283839, 0.68408046, 0.25502302, 0.95976614,

0.59214115, 0.13663711],

[0.28087456, 0.33127607, 0.15530412, 0.76558121,

0.83389773, 0.03735974, 0.98717738, 0.71432229,

0.54881366, 0.86893953],

[0.77995937, 0.99555600, 0.29688434, 0.15646162,

0.05184800, 0.37161935, 0.12998491, 0.09377296,

0.36882507, 0.36583435],

[0.37851836, 0.05315792, 0.63144617, 0.25003433,

0.69586032, 0.11393988, 0.92362096, 0.88045438,

0.93530252, 0.68275072],

[0.86486596, 0.83236675, 0.82960664, 0.57796630,

0.25724233, 0.84841095, 0.90862812, 0.64414887,

0.35652720, 0.71026066],

[0.01383268, 0.34060930, 0.76084285, 0.70800694,

0.87634056, 0.08213693, 0.54655021, 0.98123181,

0.44080053, 0.86815815]])

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

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

plt.subplot(411)

plt.plot(y1)

plt.subplot(412)

plt.plot(y2)

plt.subplot(413)

with pytest.raises(ValueError):

plt.plot((y1, y2))

plt.subplot(414)

plt.plot(xdata[:, 1], xdata[1, :], 'o')

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(['const_xy'])

def test_const_xy():

plt.subplot(311)

plt.plot(np.arange(10), np.ones(10))

plt.subplot(312)

plt.plot(np.ones(10), np.arange(10))

plt.subplot(313)

plt.plot(np.ones(10), np.ones(10), 'o')

def test_polar_twice():

fig = plt.figure()

plt.polar([1, 2], [.1, .2])

plt.polar([3, 4], [.3, .4])

assert len(fig.axes) == 1, 'More than one polar axes created.'

@check_figures_equal()

def test_polar_wrap(fig_test, fig_ref):

ax = fig_test.add_subplot(projection="polar")

ax.plot(np.deg2rad([179, -179]), [0.2, 0.1])

ax.plot(np.deg2rad([2, -2]), [0.2, 0.1])

ax = fig_ref.add_subplot(projection="polar")

ax.plot(np.deg2rad([179, 181]), [0.2, 0.1])

ax.plot(np.deg2rad([2, 358]), [0.2, 0.1])

@check_figures_equal()

def test_polar_units_1(fig_test, fig_ref):

import matplotlib.testing.jpl_units as units

units.register()

xs = [30.0, 45.0, 60.0, 90.0]

ys = [1.0, 2.0, 3.0, 4.0]

plt.figure(fig_test.number)

plt.polar([x * units.deg for x in xs], ys)

ax = fig_ref.add_subplot(projection="polar")

ax.plot(np.deg2rad(xs), ys)

ax.set(xlabel="deg")

@check_figures_equal()

def test_polar_units_2(fig_test, fig_ref):

import matplotlib.testing.jpl_units as units

units.register()

xs = [30.0, 45.0, 60.0, 90.0]

xs_deg = [x * units.deg for x in xs]

ys = [1.0, 2.0, 3.0, 4.0]

ys_km = [y * units.km for y in ys]

plt.figure(fig_test.number)

# test {theta,r}units.

plt.polar(xs_deg, ys_km, thetaunits="rad", runits="km")

assert isinstance(plt.gca().get_xaxis().get_major_formatter(),

units.UnitDblFormatter)

ax = fig_ref.add_subplot(projection="polar")

ax.plot(np.deg2rad(xs), ys)

ax.xaxis.set_major_formatter(mticker.FuncFormatter("{:.12}".format))

ax.set(xlabel="rad", ylabel="km")

@image_comparison(['polar_rmin'], style='default')

def test_polar_rmin():

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_rmax(2.0)

ax.set_rmin(0.5)

@image_comparison(['polar_negative_rmin'], style='default')

def test_polar_negative_rmin():

r = np.arange(-3.0, 0.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_rmax(0.0)

ax.set_rmin(-3.0)

@image_comparison(['polar_rorigin'], style='default')

def test_polar_rorigin():

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_rmax(2.0)

ax.set_rmin(0.5)

ax.set_rorigin(0.0)

@image_comparison(['polar_invertedylim.png'], style='default')

def test_polar_invertedylim():

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.set_ylim(2, 0)

@image_comparison(['polar_invertedylim_rorigin.png'], style='default')

def test_polar_invertedylim_rorigin():

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.yaxis.set_inverted(True)

# Set the rlims to inverted (2, 0) without calling set_rlim, to check that

# viewlims are correctly unstaled before draw()ing.

ax.plot([0, 0], [0, 2], c="none")

ax.margins(0)

ax.set_rorigin(3)

@image_comparison(['polar_theta_position'], style='default')

def test_polar_theta_position():

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

fig = plt.figure()

ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)

ax.plot(theta, r)

ax.set_theta_zero_location("NW", 30)

ax.set_theta_direction('clockwise')

@image_comparison(['polar_rlabel_position'], style='default')

def test_polar_rlabel_position():

fig = plt.figure()

ax = fig.add_subplot(111, projection='polar')

ax.set_rlabel_position(315)

ax.tick_params(rotation='auto')

@image_comparison(['polar_theta_wedge'], style='default')

def test_polar_theta_limits():

r = np.arange(0, 3.0, 0.01)

theta = 2*np.pi*r

theta_mins = np.arange(15.0, 361.0, 90.0)

theta_maxs = np.arange(50.0, 361.0, 90.0)

DIRECTIONS = ('out', 'in', 'inout')

fig, axs = plt.subplots(len(theta_mins), len(theta_maxs),

subplot_kw={'polar': True},

figsize=(8, 6))

for i, start in enumerate(theta_mins):

for j, end in enumerate(theta_maxs):

ax = axs[i, j]

ax.plot(theta, r)

if start < end:

ax.set_thetamin(start)

ax.set_thetamax(end)

else:

# Plot with clockwise orientation instead.

ax.set_thetamin(end)

ax.set_thetamax(start)

ax.set_theta_direction('clockwise')

ax.tick_params(tick1On=True, tick2On=True,

direction=DIRECTIONS[i % len(DIRECTIONS)],

rotation='auto')

ax.yaxis.set_tick_params(label2On=True, rotation='auto')

@check_figures_equal(extensions=["png"])

def test_polar_rlim(fig_test, fig_ref):

ax = fig_test.subplots(subplot_kw={'polar': True})

ax.set_rlim(top=10)

ax.set_rlim(bottom=.5)

ax = fig_ref.subplots(subplot_kw={'polar': True})

ax.set_rmax(10.)

ax.set_rmin(.5)

@check_figures_equal(extensions=["png"])

def test_polar_rlim_bottom(fig_test, fig_ref):

ax = fig_test.subplots(subplot_kw={'polar': True})

ax.set_rlim(bottom=[.5, 10])

ax = fig_ref.subplots(subplot_kw={'polar': True})

ax.set_rmax(10.)

ax.set_rmin(.5)

def test_polar_rlim_zero():

ax = plt.figure().add_subplot(projection='polar')

ax.plot(np.arange(10), np.arange(10) + .01)

assert ax.get_ylim()[0] == 0

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

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

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

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

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

ax = plt.gca()

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

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

@image_comparison(['axhspan_epoch'])

def test_axhspan_epoch():

from datetime import datetime

import matplotlib.testing.jpl_units as units

units.register()

# generate some data

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

tf = units.Epoch("ET", dt=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

class FauxMouseEvent:

def __init__(self, x, y):

self.x = x

self.y = y

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)

assert hb.contains(FauxMouseEvent(400, 300))[0]

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

def test_hexbin_log():

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

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)

@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 = plt.figure()

ax = fig.add_subplot(111)

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

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

def test_imshow_clip():