fig = plt.figure(layout='tight')

gs = gridspec.GridSpec(3, 3)

ax = fig.add_subplot(gs[0, :2])

ax.plot(np.arange(0, 1e6, 1000))

ax.set_ylabel('Ylabel0 0')

ax = fig.add_subplot(gs[0, -1])

ax.plot(np.arange(0, 1e4, 100))

for i in range(3):

ax = fig.add_subplot(gs[1, i])

ax.set_ylabel('YLabel1 %d' % i)

ax.set_xlabel('XLabel1 %d' % i)

if i in [0, 2]:

ax.xaxis.set_label_position("top")

ax.xaxis.tick_top()

if i == 0:

for tick in ax.get_xticklabels():

tick.set_rotation(90)

if i == 2:

ax.yaxis.set_label_position("right")

ax.yaxis.tick_right()

for i in range(3):

ax = fig.add_subplot(gs[2, i])

ax.set_xlabel(f'XLabel2 {i}')

ax.set_ylabel(f'YLabel2 {i}')

if i == 2:

ax.plot(np.arange(0, 1e4, 10))

ax.yaxis.set_label_position("right")

ax.yaxis.tick_right()

for tick in ax.get_xticklabels():

tick.set_rotation(90)

for layout in ['tight', 'constrained']:

fig, axs = plt.subplots(1, 2, layout=layout, width_ratios=[2, 1])

ax = axs[0]

ax.plot(np.arange(0, 1e6, 1000))

ax.set_title('Title0 left', loc='left')

ax.set_title('Title0 center', loc='center')

ax.set_title('Title0 right', loc='right')

ax = axs[1]

ax.plot(np.arange(0, 1e4, 100))

ax.set_title('Title1')

ax.set_xlabel('Xlabel0')

ax.xaxis.set_label_position("top")

ax.xaxis.tick_top()

for tick in ax.get_xticklabels():

tick.set_rotation(90)

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

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

ax.set_xlabel('Boo')

ax.set_xlabel('Who')

ax.plot(np.arange(4)**nn, np.arange(4)**nn)

fig.align_ylabels()

fig.align_xlabels()

fig.draw_without_rendering()

xn = np.zeros(4)

yn = np.zeros(4)

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

yn[nn] = ax.xaxis.label.get_position()[1]

xn[nn] = ax.yaxis.label.get_position()[0]

np.testing.assert_allclose(xn[:2], xn[2:])

np.testing.assert_allclose(yn[::2], yn[1::2])

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

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

ax.set_xlabel('Boo')

ax.set_xlabel('Who')

pc = ax.pcolormesh(np.random.randn(10, 10))

fig.colorbar(pc, ax=ax)

fig.align_ylabels()

fig.align_xlabels()

fig.draw_without_rendering()

xn = np.zeros(4)

yn = np.zeros(4)

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

yn[nn] = ax.xaxis.label.get_position()[1]

xn[nn] = ax.yaxis.label.get_position()[0]

np.testing.assert_allclose(xn[:2], xn[2:])

# pyplot figure creation, selection, and closing with label/number/instance

plt.close('all')

fig_today = plt.figure('today')

plt.figure(3)

plt.figure('tomorrow')

plt.figure()

plt.figure(0)

plt.figure(1)

plt.figure(3)

assert plt.get_fignums() == [0, 1, 3, 4, 5]

assert plt.get_figlabels() == ['', 'today', '', 'tomorrow', '']

plt.close(10)

plt.close()

plt.close(5)

plt.close('tomorrow')

assert plt.get_fignums() == [0, 1]

assert plt.get_figlabels() == ['', 'today']

plt.figure(fig_today)

assert plt.gcf() == fig_today

with pytest.raises(ValueError):

plt.close('all')

fig = plt.figure(1)

with pytest.warns(mpl.MatplotlibDeprecationWarning,

match="Changing 'Figure.number' is deprecated"):

fig.number = 2

# standalone figures do not have a figure attribute

fig = Figure()

with pytest.raises(AttributeError):

fig.number

# but one can set one

with pytest.warns(mpl.MatplotlibDeprecationWarning,

match="Changing 'Figure.number' is deprecated"):

fig.number = 5

assert fig.number == 5

# even though it's not known by pyplot

# pyplot figure creation, selection and closing with fignum_exists

plt.figure('one')

plt.figure(2)

plt.figure('three')

plt.figure()

assert plt.fignum_exists('one')

assert plt.fignum_exists(2)

assert plt.fignum_exists('three')

assert plt.fignum_exists(4)

plt.close('one')

plt.close(4)

assert not plt.fignum_exists('one')

# test if existing figure is cleared with figure() and subplots()

text1 = 'A fancy plot'

text2 = 'Really fancy!'

fig0 = plt.figure(num=1)

fig0.suptitle(text1)

assert [t.get_text() for t in fig0.texts] == [text1]

fig1 = plt.figure(num=1, clear=False)

fig1.text(0.5, 0.5, text2)

assert fig0 is fig1

assert [t.get_text() for t in fig1.texts] == [text1, text2]

fig2, ax2 = plt.subplots(2, 1, num=1, clear=True)

assert fig0 is fig2

# named figure support

fig = plt.figure('today')

ax = fig.add_subplot()

ax.set_title(fig.get_label())

ax.plot(np.arange(5))

# plot red line in a different figure.

plt.figure('tomorrow')

plt.plot([0, 1], [1, 0], 'r')

# Return to the original; make sure the red line is not there.

plt.figure('today')

fig, axs = plt.subplots(2)

axs[0].plot([0, 1], [1, 0], label='x', color='g')

axs[0].plot([0, 1], [0, 1], label='y', color='r')

axs[0].plot([0, 1], [0.5, 0.5], label='y', color='k')

axs[1].plot([0, 1], [1, 0], label='_y', color='r')

axs[1].plot([0, 1], [0, 1], label='z', color='b')

fig = plt.figure()

# test that gca() picks up Axes created via add_axes()

ax0 = fig.add_axes([0, 0, 1, 1])

assert fig.gca() is ax0

# test that gca() picks up Axes created via add_subplot()

ax1 = fig.add_subplot(111)

assert fig.gca() is ax1

# add_axes on an existing Axes should not change stored order, but will

# make it current.

fig.add_axes(ax0)

assert fig.axes == [ax0, ax1]

assert fig.gca() is ax0

# sca() should not change stored order of Axes, which is order added.

fig.sca(ax0)

assert fig.axes == [ax0, ax1]

# add_subplot on an existing Axes should not change stored order, but will

# make it current.

fig.add_subplot(ax1)

assert fig.axes == [ax0, ax1]

fig = plt.figure()

fig.add_subplot(axes_class=Axes)

with pytest.raises(ValueError):

fig.add_subplot(axes_class=Axes, projection="3d")

with pytest.raises(ValueError):

fig.add_subplot(axes_class=Axes, polar=True)

with pytest.raises(ValueError):

fig.add_subplot(projection="3d", polar=True)

with pytest.raises(TypeError):

fig = plt.figure()

with pytest.raises(ValueError,

match='Number of columns must be a positive integer'):

fig.add_subplot(2, 0, 1)

with pytest.raises(ValueError,

match='Number of rows must be a positive integer'):

fig.add_subplot(0, 2, 1)

with pytest.raises(ValueError, match='num must be an integer with '

'1 <= num <= 4'):

fig.add_subplot(2, 2, 0)

with pytest.raises(ValueError, match='num must be an integer with '

'1 <= num <= 4'):

fig.add_subplot(2, 2, 5)

with pytest.raises(ValueError, match='num must be an integer with '

'1 <= num <= 4'):

fig.add_subplot(2, 2, 0.5)

with pytest.raises(ValueError, match='must be a three-digit integer'):

fig.add_subplot(42)

with pytest.raises(ValueError, match='must be a three-digit integer'):

fig.add_subplot(1000)

with pytest.raises(TypeError, match='takes 1 or 3 positional arguments '

'but 2 were given'):

fig.add_subplot(2, 2)

with pytest.raises(TypeError, match='takes 1 or 3 positional arguments '

'but 4 were given'):

fig.add_subplot(1, 2, 3, 4)

with pytest.raises(ValueError,

match="Number of rows must be a positive integer, "

"not '2'"):

fig.add_subplot('2', 2, 1)

with pytest.raises(ValueError,

match='Number of columns must be a positive integer, '

'not 2.0'):

fig.add_subplot(2, 2.0, 1)

_, ax = plt.subplots()

with pytest.raises(ValueError,

match='The Axes must have been created in the '

'present figure'):

fig, ax = plt.subplots()

fps = mpl.font_manager.FontProperties(size='large', weight='bold')

txt = fig.suptitle('fontprops title', fontproperties=fps)

assert txt.get_fontsize() == fps.get_size_in_points()

fig = plt.figure(figsize=(4, 3))

sf1, sf2 = fig.subfigures(1, 2)

sf2.set_facecolor('white')

sf1.subplots()

sf2.subplots()

fig.suptitle("This is a visible suptitle.")

# verify the first subfigure facecolor is the default transparent

assert sf1.get_facecolor() == (0.0, 0.0, 0.0, 0.0)

# verify the second subfigure facecolor is white

fig, ax = plt.subplots()

assert fig.get_suptitle() == ""

assert fig.get_supxlabel() == ""

assert fig.get_supylabel() == ""

fig.suptitle('suptitle')

assert fig.get_suptitle() == 'suptitle'

fig.supxlabel('supxlabel')

assert fig.get_supxlabel() == 'supxlabel'

fig.supylabel('supylabel')

fig = plt.figure()

title = fig.suptitle('suptitle')

xlabel = fig.supxlabel('supxlabel')

ylabel = fig.supylabel('supylabel')

assert len(fig.texts) == 3

assert fig._suptitle is not None

assert fig._supxlabel is not None

assert fig._supylabel is not None

title.remove()

assert fig._suptitle is None

xlabel.remove()

assert fig._supxlabel is None

ylabel.remove()

assert fig._supylabel is None

# We want an image which has a background color and an alpha of 0.4.

fig = plt.figure(figsize=[2, 1])

fig.set_facecolor((0, 1, 0.4))

fig.patch.set_alpha(0.4)

fig.patches.append(mpl.patches.CirclePolygon(

# This is a regression test for matplotlib/matplotlib#3196. If one of the

# arguments returned by _as_mpl_axes defines __getitem__ but is not

# iterable, this would raise an exception. This is because we check

# whether the arguments are iterable, and if so we try and convert them

# to a tuple. However, the ``iterable`` function returns True if

# __getitem__ is present, but some classes can define __getitem__ without

# being iterable. The tuple conversion is now done in a try...except in

# case it fails.

class MyAxes(Axes):

def __init__(self, *args, myclass=None, **kwargs):

Axes.__init__(self, *args, **kwargs)

class MyClass:

def __getitem__(self, item):

if item != 'a':

raise ValueError("item should be a")

def _as_mpl_axes(self):

return MyAxes, {'myclass': self}

fig = plt.figure()

fig.add_subplot(1, 1, 1, projection=MyClass())

fig = plt.figure()

# check figwidth

fig.set_figwidth(5)

assert fig.get_figwidth() == 5

# check figheight

fig.set_figheight(1)

assert fig.get_figheight() == 1

# check using set_size_inches

fig.set_size_inches(2, 4)

assert fig.get_figwidth() == 2

assert fig.get_figheight() == 4

# check using tuple to first argument

fig.set_size_inches((1, 3))

assert fig.get_figwidth() == 1

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

axs[-1, -1].remove()

for ax in axs.ravel()[:-1]:

assert ax in fig.axes

assert axs[-1, -1] not in fig.axes

w, h = plt.figaspect(np.float64(2) / np.float64(1))

assert h / w == 2

w, h = plt.figaspect(2)

assert h / w == 2

w, h = plt.figaspect(np.zeros((1, 2)))

assert h / w == 0.5

w, h = plt.figaspect(np.zeros((2, 2)))

date = ['3 Jan 2013', '4 Jan 2013', '5 Jan 2013', '6 Jan 2013',

'7 Jan 2013', '8 Jan 2013', '9 Jan 2013', '10 Jan 2013',

'11 Jan 2013', '12 Jan 2013', '13 Jan 2013', '14 Jan 2013']

time = ['16:44:00', '16:45:00', '16:46:00', '16:47:00', '16:48:00',

'16:49:00', '16:51:00', '16:52:00', '16:53:00', '16:55:00',

'16:56:00', '16:57:00']

angle = 60

minors = [1, 2, 3, 4, 5, 6, 7]

x = mdates.datestr2num(date)

y = mdates.datestr2num(time)

fig, ax = plt.subplots()

ax.plot(x, y)

ax.yaxis_date()

ax.xaxis_date()

ax.xaxis.set_minor_locator(AutoMinorLocator(2))

with warnings.catch_warnings():

warnings.filterwarnings(

'ignore',

'FixedFormatter should only be used together with FixedLocator')

ax.xaxis.set_minor_formatter(FixedFormatter(minors))

fig.autofmt_xdate(0.2, angle, 'right', which)

if which in ('both', 'major'):

for label in fig.axes[0].get_xticklabels(False, 'major'):

assert int(label.get_rotation()) == angle

if which in ('both', 'minor'):

for label in fig.axes[0].get_xticklabels(True, 'minor'):

# check works with a colorbar.

# with constrained layout, colorbars do not have a gridspec,

# but autofmt_xdate checks if all axes have a gridspec before being

# applied.

fig, ax = plt.subplots(layout="constrained")

im = ax.imshow([[1, 4, 6], [2, 3, 5]])

plt.colorbar(im)

fig.autofmt_xdate()

fig.draw_without_rendering()

label = ax.get_xticklabels(which='major')[1]

fig = plt.figure(figsize=(4, 4))

fig.draw_without_rendering()

assert fig.canvas.renderer.height == 400

assert fig.canvas.renderer.width == 400

fig.dpi = 50

fig.draw_without_rendering()

assert fig.canvas.renderer.height == 200

with pytest.raises(ValueError):

plt.figure(figsize=(width, height))

fig = plt.figure()

with pytest.raises(ValueError):

fig = plt.figure()

with pytest.raises(TypeError,

match="missing 1 required positional argument: 'rect'"):

fig.add_axes()

with pytest.raises(ValueError):

fig.add_axes((.1, .1, .5, np.nan))

with pytest.raises(TypeError, match="multiple values for argument 'rect'"):

fig.add_axes([0, 0, 1, 1], rect=[0, 0, 1, 1])

fig2, ax = plt.subplots()

with pytest.raises(ValueError,

match="The Axes must have been created in the present "

"figure"):

fig.add_axes(ax)

fig2.delaxes(ax)

with pytest.raises(TypeError, match=r"add_axes\(\) takes 1 positional arguments"):

fig2.add_axes(ax, "extra positional argument")

with pytest.raises(TypeError, match=r"add_axes\(\) takes 1 positional arguments"):

fig, axs = plt.subplots(2, 2, sharex=True, sharey=True, squeeze=False)

for ax in axs.flat:

ax.plot([10, 20, 30], [10, 20, 30])

ax.set_yscale("log")

ax.set_xscale("log")

for ax in axs[0, :]:

assert 0 == len(ax.xaxis.get_ticklabels(which='both'))

for ax in axs[1, :]:

assert 0 < len(ax.xaxis.get_ticklabels(which='both'))

for ax in axs[:, 1]:

assert 0 == len(ax.yaxis.get_ticklabels(which='both'))

for ax in axs[:, 0]:

fig = plt.figure()

msg = r"savefig\(\) takes 2 positional arguments but 3 were given"

with pytest.raises(TypeError, match=msg):

fig = plt.figure()

for format in ['png', 'pdf', 'svg', 'tif', 'jpg']:

with pytest.raises(TypeError):

fig = plt.figure()

# Intentionally use an invalid module name.

with pytest.raises(ModuleNotFoundError, match="No module named '@absent'"):

fig.savefig("test", backend="module://@absent")

with pytest.raises(ValueError,

match="The 'pdf' backend does not support png output"):

fig, ax = plt.subplots()

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

with io.BytesIO() as buf:

fig.savefig(buf, format='png')

ratio1 = Image.open(buf)

ratio1.load()

fig, ax = plt.subplots()

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

fig.canvas._set_device_pixel_ratio(2)

with io.BytesIO() as buf:

fig.savefig(buf, format='png')

ratio2 = Image.open(buf)

ratio2.load()

fig = plt.figure(layout='compressed')

fig.savefig(io.BytesIO(), bbox_inches='tight')

fig, ax = plt.subplots()

pc = ax.pcolormesh(np.random.randn(2, 2))

cbar = fig.colorbar(pc, aspect=40)

fig.savefig(io.BytesIO(), bbox_inches=mpl.transforms.Bbox([[0, 0], [4, 4]]))

# Check that an aspect ratio has been applied.

assert (cbar.ax.get_position(original=True).bounds !=

# create two transparent subfigures with corresponding transparent inset

# axes. the entire background of the image should be transparent.

gs1 = fig_test.add_gridspec(3, 3, left=0.05, wspace=0.05)

f1 = fig_test.add_subfigure(gs1[:, :])

f2 = f1.add_subfigure(gs1[0, 0])

ax12 = f2.add_subplot(gs1[:, :])

ax1 = f1.add_subplot(gs1[:-1, :])

iax1 = ax1.inset_axes([.1, .2, .3, .4])

iax2 = iax1.inset_axes([.1, .2, .3, .4])

ax2 = fig_test.add_subplot(gs1[-1, :-1])

ax3 = fig_test.add_subplot(gs1[-1, -1])

for ax in [ax12, ax1, iax1, iax2, ax2, ax3]:

ax.set(xticks=[], yticks=[])

fig = Figure(layout=None)

assert not fig.get_tight_layout()

assert not fig.get_constrained_layout()

fig = Figure(layout='tight')

assert fig.get_tight_layout()

assert not fig.get_constrained_layout()

fig = Figure(layout='constrained')

assert not fig.get_tight_layout()

fig, ax = plt.subplots(layout="constrained")

with pytest.warns(UserWarning):

# this should warn,

fig.subplots_adjust(top=0.8)

assert isinstance(fig.get_layout_engine(), ConstrainedLayoutEngine)

# Using layout + (tight|constrained)_layout warns, but the former takes

# precedence.

wst = "The Figure parameters 'layout' and 'tight_layout'"

with pytest.warns(UserWarning, match=wst):

fig = Figure(layout='tight', tight_layout=False)

assert isinstance(fig.get_layout_engine(), TightLayoutEngine)

wst = "The Figure parameters 'layout' and 'constrained_layout'"

with pytest.warns(UserWarning, match=wst):

fig = Figure(layout='constrained', constrained_layout=False)

assert not isinstance(fig.get_layout_engine(), TightLayoutEngine)

assert isinstance(fig.get_layout_engine(), ConstrainedLayoutEngine)

with pytest.raises(ValueError,

match="Invalid value for 'layout'"):

Figure(layout='foobar')

# test that layouts can be swapped if no colorbar:

fig, ax = plt.subplots(layout="constrained")

fig.set_layout_engine("tight")

assert isinstance(fig.get_layout_engine(), TightLayoutEngine)

fig.set_layout_engine("constrained")

assert isinstance(fig.get_layout_engine(), ConstrainedLayoutEngine)

# test that layouts cannot be swapped if there is a colorbar:

fig, ax = plt.subplots(layout="constrained")

pc = ax.pcolormesh(np.random.randn(2, 2))

fig.colorbar(pc)

with pytest.raises(RuntimeError, match='Colorbar layout of new layout'):

fig.set_layout_engine("tight")

fig.set_layout_engine("none")

with pytest.raises(RuntimeError, match='Colorbar layout of new layout'):

fig.set_layout_engine("tight")

fig, ax = plt.subplots(layout="tight")

pc = ax.pcolormesh(np.random.randn(2, 2))

fig.colorbar(pc)

with pytest.raises(RuntimeError, match='Colorbar layout of new layout'):

fig.set_layout_engine("constrained")

fig.set_layout_engine("none")

assert isinstance(fig.get_layout_engine(), PlaceHolderLayoutEngine)

with pytest.raises(RuntimeError, match='Colorbar layout of new layout'):

for fig, autolayout in zip([fig_ref, fig_test], [False, True]):

with mpl.rc_context({'figure.autolayout': autolayout}):

axes = fig.subplots(ncols=2)

fig.tight_layout(w_pad=10)

"""

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

with pytest.warns(UserWarning, match='The figure layout has changed to'):

fig = Figure()

fig.tight_layout()

# subsequent calls should not warn

fig.tight_layout()

fig_test.dpi = 100

fig_ref.dpi = 100

fig_test.subplots()

l1 = plt.Line2D([.2, .7], [.7, .7], gid='l1')

l2 = plt.Line2D([.2, .7], [.8, .8], gid='l2')

r1 = plt.Circle((20, 20), 100, transform=None, gid='C1')

r2 = plt.Circle((.7, .5), .05, gid='C2')

r3 = plt.Circle((4.5, .8), .55, transform=fig_test.dpi_scale_trans,

facecolor='crimson', gid='C3')

for a in [l1, l2, r1, r2, r3]:

fig_test.add_artist(a)

l2.remove()

ax2 = fig_ref.subplots()

l1 = plt.Line2D([.2, .7], [.7, .7], transform=fig_ref.transFigure,

gid='l1', zorder=21)

r1 = plt.Circle((20, 20), 100, transform=None, clip_on=False, zorder=20,

gid='C1')

r2 = plt.Circle((.7, .5), .05, transform=fig_ref.transFigure, gid='C2',

zorder=20)

r3 = plt.Circle((4.5, .8), .55, transform=fig_ref.dpi_scale_trans,

facecolor='crimson', clip_on=False, zorder=20, gid='C3')

for a in [l1, r1, r2, r3]:

out = tmp_path / f"test.{fmt}"

plt.savefig(out)

with out.open("rb") as file:

# All the supported formats include the format name (case-insensitive)

# in the first 100 bytes.

fig, ax = plt.subplots()

ax.set_xlim(0, 1)

t = ax.text(1., 0.5, 'This dangles over end')

renderer = fig.canvas.get_renderer()

x1Nom0 = 9.035 # inches

assert abs(t.get_tightbbox(renderer).x1 - x1Nom0 * fig.dpi) < 2

assert abs(ax.get_tightbbox(renderer).x1 - x1Nom0 * fig.dpi) < 2

assert abs(fig.get_tightbbox(renderer).x1 - x1Nom0) < 0.05

assert abs(fig.get_tightbbox(renderer).x0 - 0.679) < 0.05

# now exclude t from the tight bbox so now the bbox is quite a bit

# smaller

t.set_in_layout(False)

x1Nom = 7.333

assert abs(ax.get_tightbbox(renderer).x1 - x1Nom * fig.dpi) < 2

assert abs(fig.get_tightbbox(renderer).x1 - x1Nom) < 0.05

t.set_in_layout(True)

x1Nom = 7.333

assert abs(ax.get_tightbbox(renderer).x1 - x1Nom0 * fig.dpi) < 2

# test bbox_extra_artists method...

assert abs(ax.get_tightbbox(renderer, bbox_extra_artists=[]).x1

# Check that units can set the formatter after an Axes removal

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

axs[1].remove()

axs[0].plot([datetime(2000, 1, 1), datetime(2000, 2, 1)], [0, 1])

assert isinstance(axs[0].xaxis.get_major_formatter(),

mdates.AutoDateFormatter)

# Check that manually setting the formatter, then removing Axes keeps

# the set formatter.

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

axs[1].xaxis.set_major_formatter(ScalarFormatter())

axs[1].remove()

axs[0].plot([datetime(2000, 1, 1), datetime(2000, 2, 1)], [0, 1])

assert isinstance(axs[0].xaxis.get_major_formatter(),

# Simple smoke test to make sure removing a shared axis works

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

axs[0].remove()

# we test the following figure clearing scenarios:

fig = plt.figure()

# a) an empty figure

fig.clear()

assert fig.axes == []

# b) a figure with a single unnested axes

ax = fig.add_subplot(111)

getattr(fig, clear_meth)()

assert fig.axes == []

# c) a figure multiple unnested axes

axes = [fig.add_subplot(2, 1, i+1) for i in range(2)]

getattr(fig, clear_meth)()

assert fig.axes == []

# d) a figure with a subfigure

gs = fig.add_gridspec(ncols=2, nrows=1)

subfig = fig.add_subfigure(gs[0])

subaxes = subfig.add_subplot(111)

getattr(fig, clear_meth)()

assert subfig not in fig.subfigs

assert fig.axes == []

# e) a figure with a subfigure and a subplot

subfig = fig.add_subfigure(gs[0])

subaxes = subfig.add_subplot(111)

mainaxes = fig.add_subplot(gs[1])

# e.1) removing just the axes leaves the subplot

mainaxes.remove()

assert fig.axes == [subaxes]

# e.2) removing just the subaxes leaves the subplot

# and subfigure

mainaxes = fig.add_subplot(gs[1])

subaxes.remove()

assert fig.axes == [mainaxes]

assert subfig in fig.subfigs

# e.3) clearing the subfigure leaves the subplot

subaxes = subfig.add_subplot(111)

assert mainaxes in fig.axes

assert subaxes in fig.axes

getattr(subfig, clear_meth)()

assert subfig in fig.subfigs

assert subaxes not in subfig.axes

assert subaxes not in fig.axes

assert mainaxes in fig.axes

# e.4) clearing the whole thing

subaxes = subfig.add_subplot(111)

getattr(fig, clear_meth)()

assert fig.axes == []

assert fig.subfigs == []

# f) multiple subfigures

subfigs = [fig.add_subfigure(gs[i]) for i in [0, 1]]

subaxes = [sfig.add_subplot(111) for sfig in subfigs]

assert all(ax in fig.axes for ax in subaxes)

assert all(sfig in fig.subfigs for sfig in subfigs)

# f.1) clearing only one subfigure

getattr(subfigs[0], clear_meth)()

assert subaxes[0] not in fig.axes

assert subaxes[1] in fig.axes

assert subfigs[1] in fig.subfigs

# f.2) clearing the whole thing

getattr(subfigs[1], clear_meth)()

subfigs = [fig.add_subfigure(gs[i]) for i in [0, 1]]