Add files using upload-large-folder tool

63f8f42 verified 4 months ago

13 kB

import copy
import importlib
import os
import signal
import sys

from datetime import date, datetime
from unittest import mock

import pytest

import matplotlib
from matplotlib import pyplot as plt
from matplotlib._pylab_helpers import Gcf
from matplotlib import _c_internal_utils

try:
    from matplotlib.backends.qt_compat import QtGui  # type: ignore[attr-defined]  # noqa: E501, F401
    from matplotlib.backends.qt_compat import QtWidgets  # type: ignore[attr-defined]
    from matplotlib.backends.qt_editor import _formlayout
except ImportError:
    pytestmark = pytest.mark.skip('No usable Qt bindings')


_test_timeout = 60  # A reasonably safe value for slower architectures.


@pytest.fixture
def qt_core(request):
    from matplotlib.backends.qt_compat import QtCore
    return QtCore


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_fig_close():

    # save the state of Gcf.figs
    init_figs = copy.copy(Gcf.figs)

    # make a figure using pyplot interface
    fig = plt.figure()

    # simulate user clicking the close button by reaching in
    # and calling close on the underlying Qt object
    fig.canvas.manager.window.close()

    # assert that we have removed the reference to the FigureManager
    # that got added by plt.figure()
    assert init_figs == Gcf.figs


@pytest.mark.parametrize(
    "qt_key, qt_mods, answer",
    [
        ("Key_A", ["ShiftModifier"], "A"),
        ("Key_A", [], "a"),
        ("Key_A", ["ControlModifier"], ("ctrl+a")),
        (
            "Key_Aacute",
            ["ShiftModifier"],
            "\N{LATIN CAPITAL LETTER A WITH ACUTE}",
        ),
        ("Key_Aacute", [], "\N{LATIN SMALL LETTER A WITH ACUTE}"),
        ("Key_Control", ["AltModifier"], ("alt+control")),
        ("Key_Alt", ["ControlModifier"], "ctrl+alt"),
        (
            "Key_Aacute",
            ["ControlModifier", "AltModifier", "MetaModifier"],
            ("ctrl+alt+meta+\N{LATIN SMALL LETTER A WITH ACUTE}"),
        ),
        # We do not currently map the media keys, this may change in the
        # future.  This means the callback will never fire
        ("Key_Play", [], None),
        ("Key_Backspace", [], "backspace"),
        (
            "Key_Backspace",
            ["ControlModifier"],
            "ctrl+backspace",
        ),
    ],
    ids=[
        'shift',
        'lower',
        'control',
        'unicode_upper',
        'unicode_lower',
        'alt_control',
        'control_alt',
        'modifier_order',
        'non_unicode_key',
        'backspace',
        'backspace_mod',
    ]
)
@pytest.mark.parametrize('backend', [
    # Note: the value is irrelevant; the important part is the marker.
    pytest.param(
        'Qt5Agg',
        marks=pytest.mark.backend('Qt5Agg', skip_on_importerror=True)),
    pytest.param(
        'QtAgg',
        marks=pytest.mark.backend('QtAgg', skip_on_importerror=True)),
])
def test_correct_key(backend, qt_core, qt_key, qt_mods, answer, monkeypatch):
    """
    Make a figure.
    Send a key_press_event event (using non-public, qtX backend specific api).
    Catch the event.
    Assert sent and caught keys are the same.
    """
    from matplotlib.backends.qt_compat import _to_int, QtCore

    if sys.platform == "darwin" and answer is not None:
        answer = answer.replace("ctrl", "cmd")
        answer = answer.replace("control", "cmd")
        answer = answer.replace("meta", "ctrl")
    result = None
    qt_mod = QtCore.Qt.KeyboardModifier.NoModifier
    for mod in qt_mods:
        qt_mod |= getattr(QtCore.Qt.KeyboardModifier, mod)

    class _Event:
        def isAutoRepeat(self): return False
        def key(self): return _to_int(getattr(QtCore.Qt.Key, qt_key))

    monkeypatch.setattr(QtWidgets.QApplication, "keyboardModifiers",
                        lambda self: qt_mod)

    def on_key_press(event):
        nonlocal result
        result = event.key

    qt_canvas = plt.figure().canvas
    qt_canvas.mpl_connect('key_press_event', on_key_press)
    qt_canvas.keyPressEvent(_Event())
    assert result == answer


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_device_pixel_ratio_change():
    """
    Make sure that if the pixel ratio changes, the figure dpi changes but the
    widget remains the same logical size.
    """

    prop = 'matplotlib.backends.backend_qt.FigureCanvasQT.devicePixelRatioF'
    with mock.patch(prop) as p:
        p.return_value = 3

        fig = plt.figure(figsize=(5, 2), dpi=120)
        qt_canvas = fig.canvas
        qt_canvas.show()

        def set_device_pixel_ratio(ratio):
            p.return_value = ratio

            # The value here doesn't matter, as we can't mock the C++ QScreen
            # object, but can override the functional wrapper around it.
            # Emitting this event is simply to trigger the DPI change handler
            # in Matplotlib in the same manner that it would occur normally.
            screen.logicalDotsPerInchChanged.emit(96)

            qt_canvas.draw()
            qt_canvas.flush_events()

            # Make sure the mocking worked
            assert qt_canvas.device_pixel_ratio == ratio

        qt_canvas.manager.show()
        size = qt_canvas.size()
        screen = qt_canvas.window().windowHandle().screen()
        set_device_pixel_ratio(3)

        # The DPI and the renderer width/height change
        assert fig.dpi == 360
        assert qt_canvas.renderer.width == 1800
        assert qt_canvas.renderer.height == 720

        # The actual widget size and figure logical size don't change.
        assert size.width() == 600
        assert size.height() == 240
        assert qt_canvas.get_width_height() == (600, 240)
        assert (fig.get_size_inches() == (5, 2)).all()

        set_device_pixel_ratio(2)

        # The DPI and the renderer width/height change
        assert fig.dpi == 240
        assert qt_canvas.renderer.width == 1200
        assert qt_canvas.renderer.height == 480

        # The actual widget size and figure logical size don't change.
        assert size.width() == 600
        assert size.height() == 240
        assert qt_canvas.get_width_height() == (600, 240)
        assert (fig.get_size_inches() == (5, 2)).all()

        set_device_pixel_ratio(1.5)

        # The DPI and the renderer width/height change
        assert fig.dpi == 180
        assert qt_canvas.renderer.width == 900
        assert qt_canvas.renderer.height == 360

        # The actual widget size and figure logical size don't change.
        assert size.width() == 600
        assert size.height() == 240
        assert qt_canvas.get_width_height() == (600, 240)
        assert (fig.get_size_inches() == (5, 2)).all()


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_subplottool():
    fig, ax = plt.subplots()
    with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
        fig.canvas.manager.toolbar.configure_subplots()


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_figureoptions():
    fig, ax = plt.subplots()
    ax.plot([1, 2])
    ax.imshow([[1]])
    ax.scatter(range(3), range(3), c=range(3))
    with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
        fig.canvas.manager.toolbar.edit_parameters()


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_save_figure_return():
    fig, ax = plt.subplots()
    ax.imshow([[1]])
    prop = "matplotlib.backends.qt_compat.QtWidgets.QFileDialog.getSaveFileName"
    with mock.patch(prop, return_value=("foobar.png", None)):
        fname = fig.canvas.manager.toolbar.save_figure()
        os.remove("foobar.png")
        assert fname == "foobar.png"
    with mock.patch(prop, return_value=(None, None)):
        fname = fig.canvas.manager.toolbar.save_figure()
        assert fname is None


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_figureoptions_with_datetime_axes():
    fig, ax = plt.subplots()
    xydata = [
        datetime(year=2021, month=1, day=1),
        datetime(year=2021, month=2, day=1)
    ]
    ax.plot(xydata, xydata)
    with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
        fig.canvas.manager.toolbar.edit_parameters()


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_double_resize():
    # Check that resizing a figure twice keeps the same window size
    fig, ax = plt.subplots()
    fig.canvas.draw()
    window = fig.canvas.manager.window

    w, h = 3, 2
    fig.set_size_inches(w, h)
    assert fig.canvas.width() == w * matplotlib.rcParams['figure.dpi']
    assert fig.canvas.height() == h * matplotlib.rcParams['figure.dpi']

    old_width = window.width()
    old_height = window.height()

    fig.set_size_inches(w, h)
    assert window.width() == old_width
    assert window.height() == old_height


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_canvas_reinit():
    from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg

    called = False

    def crashing_callback(fig, stale):
        nonlocal called
        fig.canvas.draw_idle()
        called = True

    fig, ax = plt.subplots()
    fig.stale_callback = crashing_callback
    # this should not raise
    canvas = FigureCanvasQTAgg(fig)
    fig.stale = True
    assert called


@pytest.mark.backend('Qt5Agg', skip_on_importerror=True)
def test_form_widget_get_with_datetime_and_date_fields():
    from matplotlib.backends.backend_qt import _create_qApp
    _create_qApp()

    form = [
        ("Datetime field", datetime(year=2021, month=3, day=11)),
        ("Date field", date(year=2021, month=3, day=11))
    ]
    widget = _formlayout.FormWidget(form)
    widget.setup()
    values = widget.get()
    assert values == [
        datetime(year=2021, month=3, day=11),
        date(year=2021, month=3, day=11)
    ]


def _get_testable_qt_backends():
    envs = []
    for deps, env in [
            ([qt_api], {"MPLBACKEND": "qtagg", "QT_API": qt_api})
            for qt_api in ["PyQt6", "PySide6", "PyQt5", "PySide2"]
    ]:
        reason = None
        missing = [dep for dep in deps if not importlib.util.find_spec(dep)]
        if (sys.platform == "linux" and
                not _c_internal_utils.display_is_valid()):
            reason = "$DISPLAY and $WAYLAND_DISPLAY are unset"
        elif missing:
            reason = "{} cannot be imported".format(", ".join(missing))
        elif env["MPLBACKEND"] == 'macosx' and os.environ.get('TF_BUILD'):
            reason = "macosx backend fails on Azure"
        marks = []
        if reason:
            marks.append(pytest.mark.skip(
                reason=f"Skipping {env} because {reason}"))
        envs.append(pytest.param(env, marks=marks, id=str(env)))
    return envs


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_fig_sigint_override(qt_core):
    from matplotlib.backends.backend_qt5 import _BackendQT5
    # Create a figure
    plt.figure()

    # Variable to access the handler from the inside of the event loop
    event_loop_handler = None

    # Callback to fire during event loop: save SIGINT handler, then exit
    def fire_signal_and_quit():
        # Save event loop signal
        nonlocal event_loop_handler
        event_loop_handler = signal.getsignal(signal.SIGINT)

        # Request event loop exit
        qt_core.QCoreApplication.exit()

    # Timer to exit event loop
    qt_core.QTimer.singleShot(0, fire_signal_and_quit)

    # Save original SIGINT handler
    original_handler = signal.getsignal(signal.SIGINT)

    # Use our own SIGINT handler to be 100% sure this is working
    def custom_handler(signum, frame):
        pass

    signal.signal(signal.SIGINT, custom_handler)

    try:
        # mainloop() sets SIGINT, starts Qt event loop (which triggers timer
        # and exits) and then mainloop() resets SIGINT
        matplotlib.backends.backend_qt._BackendQT.mainloop()

        # Assert: signal handler during loop execution is changed
        # (can't test equality with func)
        assert event_loop_handler != custom_handler

        # Assert: current signal handler is the same as the one we set before
        assert signal.getsignal(signal.SIGINT) == custom_handler

        # Repeat again to test that SIG_DFL and SIG_IGN will not be overridden
        for custom_handler in (signal.SIG_DFL, signal.SIG_IGN):
            qt_core.QTimer.singleShot(0, fire_signal_and_quit)
            signal.signal(signal.SIGINT, custom_handler)

            _BackendQT5.mainloop()

            assert event_loop_handler == custom_handler
            assert signal.getsignal(signal.SIGINT) == custom_handler

    finally:
        # Reset SIGINT handler to what it was before the test
        signal.signal(signal.SIGINT, original_handler)


@pytest.mark.backend('QtAgg', skip_on_importerror=True)
def test_ipython():
    from matplotlib.testing import ipython_in_subprocess
    ipython_in_subprocess("qt", {(8, 24): "qtagg", (8, 15): "QtAgg", (7, 0): "Qt5Agg"})

	import copy
	import importlib
	import os
	import signal
	import sys

	from datetime import date, datetime
	from unittest import mock

	import pytest

	import matplotlib
	from matplotlib import pyplot as plt
	from matplotlib._pylab_helpers import Gcf
	from matplotlib import _c_internal_utils

	try:
	from matplotlib.backends.qt_compat import QtGui # type: ignore[attr-defined] # noqa: E501, F401
	from matplotlib.backends.qt_compat import QtWidgets # type: ignore[attr-defined]
	from matplotlib.backends.qt_editor import _formlayout
	except ImportError:
	pytestmark = pytest.mark.skip('No usable Qt bindings')


	_test_timeout = 60 # A reasonably safe value for slower architectures.


	@pytest.fixture
	def qt_core(request):
	from matplotlib.backends.qt_compat import QtCore
	return QtCore


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_fig_close():

	# save the state of Gcf.figs
	init_figs = copy.copy(Gcf.figs)

	# make a figure using pyplot interface
	fig = plt.figure()

	# simulate user clicking the close button by reaching in
	# and calling close on the underlying Qt object
	fig.canvas.manager.window.close()

	# assert that we have removed the reference to the FigureManager
	# that got added by plt.figure()
	assert init_figs == Gcf.figs


	@pytest.mark.parametrize(
	"qt_key, qt_mods, answer",
	[
	("Key_A", ["ShiftModifier"], "A"),
	("Key_A", [], "a"),
	("Key_A", ["ControlModifier"], ("ctrl+a")),
	(
	"Key_Aacute",
	["ShiftModifier"],
	"\N{LATIN CAPITAL LETTER A WITH ACUTE}",
	),
	("Key_Aacute", [], "\N{LATIN SMALL LETTER A WITH ACUTE}"),
	("Key_Control", ["AltModifier"], ("alt+control")),
	("Key_Alt", ["ControlModifier"], "ctrl+alt"),
	(
	"Key_Aacute",
	["ControlModifier", "AltModifier", "MetaModifier"],
	("ctrl+alt+meta+\N{LATIN SMALL LETTER A WITH ACUTE}"),
	),
	# We do not currently map the media keys, this may change in the
	# future. This means the callback will never fire
	("Key_Play", [], None),
	("Key_Backspace", [], "backspace"),
	(
	"Key_Backspace",
	["ControlModifier"],
	"ctrl+backspace",
	),
	],
	ids=[
	'shift',
	'lower',
	'control',
	'unicode_upper',
	'unicode_lower',
	'alt_control',
	'control_alt',
	'modifier_order',
	'non_unicode_key',
	'backspace',
	'backspace_mod',
	]
	)
	@pytest.mark.parametrize('backend', [
	# Note: the value is irrelevant; the important part is the marker.
	pytest.param(
	'Qt5Agg',
	marks=pytest.mark.backend('Qt5Agg', skip_on_importerror=True)),
	pytest.param(
	'QtAgg',
	marks=pytest.mark.backend('QtAgg', skip_on_importerror=True)),
	])
	def test_correct_key(backend, qt_core, qt_key, qt_mods, answer, monkeypatch):
	"""
	Make a figure.
	Send a key_press_event event (using non-public, qtX backend specific api).
	Catch the event.
	Assert sent and caught keys are the same.
	"""
	from matplotlib.backends.qt_compat import _to_int, QtCore

	if sys.platform == "darwin" and answer is not None:
	answer = answer.replace("ctrl", "cmd")
	answer = answer.replace("control", "cmd")
	answer = answer.replace("meta", "ctrl")
	result = None
	qt_mod = QtCore.Qt.KeyboardModifier.NoModifier
	for mod in qt_mods:
	qt_mod \|= getattr(QtCore.Qt.KeyboardModifier, mod)

	class _Event:
	def isAutoRepeat(self): return False
	def key(self): return _to_int(getattr(QtCore.Qt.Key, qt_key))

	monkeypatch.setattr(QtWidgets.QApplication, "keyboardModifiers",
	lambda self: qt_mod)

	def on_key_press(event):
	nonlocal result
	result = event.key

	qt_canvas = plt.figure().canvas
	qt_canvas.mpl_connect('key_press_event', on_key_press)
	qt_canvas.keyPressEvent(_Event())
	assert result == answer


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_device_pixel_ratio_change():
	"""
	Make sure that if the pixel ratio changes, the figure dpi changes but the
	widget remains the same logical size.
	"""

	prop = 'matplotlib.backends.backend_qt.FigureCanvasQT.devicePixelRatioF'
	with mock.patch(prop) as p:
	p.return_value = 3

	fig = plt.figure(figsize=(5, 2), dpi=120)
	qt_canvas = fig.canvas
	qt_canvas.show()

	def set_device_pixel_ratio(ratio):
	p.return_value = ratio

	# The value here doesn't matter, as we can't mock the C++ QScreen
	# object, but can override the functional wrapper around it.
	# Emitting this event is simply to trigger the DPI change handler
	# in Matplotlib in the same manner that it would occur normally.
	screen.logicalDotsPerInchChanged.emit(96)

	qt_canvas.draw()
	qt_canvas.flush_events()

	# Make sure the mocking worked
	assert qt_canvas.device_pixel_ratio == ratio

	qt_canvas.manager.show()
	size = qt_canvas.size()
	screen = qt_canvas.window().windowHandle().screen()
	set_device_pixel_ratio(3)

	# The DPI and the renderer width/height change
	assert fig.dpi == 360
	assert qt_canvas.renderer.width == 1800
	assert qt_canvas.renderer.height == 720

	# The actual widget size and figure logical size don't change.
	assert size.width() == 600
	assert size.height() == 240
	assert qt_canvas.get_width_height() == (600, 240)
	assert (fig.get_size_inches() == (5, 2)).all()

	set_device_pixel_ratio(2)

	# The DPI and the renderer width/height change
	assert fig.dpi == 240
	assert qt_canvas.renderer.width == 1200
	assert qt_canvas.renderer.height == 480

	# The actual widget size and figure logical size don't change.
	assert size.width() == 600
	assert size.height() == 240
	assert qt_canvas.get_width_height() == (600, 240)
	assert (fig.get_size_inches() == (5, 2)).all()

	set_device_pixel_ratio(1.5)

	# The DPI and the renderer width/height change
	assert fig.dpi == 180
	assert qt_canvas.renderer.width == 900
	assert qt_canvas.renderer.height == 360

	# The actual widget size and figure logical size don't change.
	assert size.width() == 600
	assert size.height() == 240
	assert qt_canvas.get_width_height() == (600, 240)
	assert (fig.get_size_inches() == (5, 2)).all()


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_subplottool():
	fig, ax = plt.subplots()
	with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
	fig.canvas.manager.toolbar.configure_subplots()


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_figureoptions():
	fig, ax = plt.subplots()
	ax.plot([1, 2])
	ax.imshow([[1]])
	ax.scatter(range(3), range(3), c=range(3))
	with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
	fig.canvas.manager.toolbar.edit_parameters()


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_save_figure_return():
	fig, ax = plt.subplots()
	ax.imshow([[1]])
	prop = "matplotlib.backends.qt_compat.QtWidgets.QFileDialog.getSaveFileName"
	with mock.patch(prop, return_value=("foobar.png", None)):
	fname = fig.canvas.manager.toolbar.save_figure()
	os.remove("foobar.png")
	assert fname == "foobar.png"
	with mock.patch(prop, return_value=(None, None)):
	fname = fig.canvas.manager.toolbar.save_figure()
	assert fname is None


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_figureoptions_with_datetime_axes():
	fig, ax = plt.subplots()
	xydata = [
	datetime(year=2021, month=1, day=1),
	datetime(year=2021, month=2, day=1)
	]
	ax.plot(xydata, xydata)
	with mock.patch("matplotlib.backends.qt_compat._exec", lambda obj: None):
	fig.canvas.manager.toolbar.edit_parameters()


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_double_resize():
	# Check that resizing a figure twice keeps the same window size
	fig, ax = plt.subplots()
	fig.canvas.draw()
	window = fig.canvas.manager.window

	w, h = 3, 2
	fig.set_size_inches(w, h)
	assert fig.canvas.width() == w * matplotlib.rcParams['figure.dpi']
	assert fig.canvas.height() == h * matplotlib.rcParams['figure.dpi']

	old_width = window.width()
	old_height = window.height()

	fig.set_size_inches(w, h)
	assert window.width() == old_width
	assert window.height() == old_height


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_canvas_reinit():
	from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg

	called = False

	def crashing_callback(fig, stale):
	nonlocal called
	fig.canvas.draw_idle()
	called = True

	fig, ax = plt.subplots()
	fig.stale_callback = crashing_callback
	# this should not raise
	canvas = FigureCanvasQTAgg(fig)
	fig.stale = True
	assert called


	@pytest.mark.backend('Qt5Agg', skip_on_importerror=True)
	def test_form_widget_get_with_datetime_and_date_fields():
	from matplotlib.backends.backend_qt import _create_qApp
	_create_qApp()

	form = [
	("Datetime field", datetime(year=2021, month=3, day=11)),
	("Date field", date(year=2021, month=3, day=11))
	]
	widget = _formlayout.FormWidget(form)
	widget.setup()
	values = widget.get()
	assert values == [
	datetime(year=2021, month=3, day=11),
	date(year=2021, month=3, day=11)
	]


	def _get_testable_qt_backends():
	envs = []
	for deps, env in [
	([qt_api], {"MPLBACKEND": "qtagg", "QT_API": qt_api})
	for qt_api in ["PyQt6", "PySide6", "PyQt5", "PySide2"]
	]:
	reason = None
	missing = [dep for dep in deps if not importlib.util.find_spec(dep)]
	if (sys.platform == "linux" and
	not _c_internal_utils.display_is_valid()):
	reason = "$DISPLAY and $WAYLAND_DISPLAY are unset"
	elif missing:
	reason = "{} cannot be imported".format(", ".join(missing))
	elif env["MPLBACKEND"] == 'macosx' and os.environ.get('TF_BUILD'):
	reason = "macosx backend fails on Azure"
	marks = []
	if reason:
	marks.append(pytest.mark.skip(
	reason=f"Skipping {env} because {reason}"))
	envs.append(pytest.param(env, marks=marks, id=str(env)))
	return envs


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_fig_sigint_override(qt_core):
	from matplotlib.backends.backend_qt5 import _BackendQT5
	# Create a figure
	plt.figure()

	# Variable to access the handler from the inside of the event loop
	event_loop_handler = None

	# Callback to fire during event loop: save SIGINT handler, then exit
	def fire_signal_and_quit():
	# Save event loop signal
	nonlocal event_loop_handler
	event_loop_handler = signal.getsignal(signal.SIGINT)

	# Request event loop exit
	qt_core.QCoreApplication.exit()

	# Timer to exit event loop
	qt_core.QTimer.singleShot(0, fire_signal_and_quit)

	# Save original SIGINT handler
	original_handler = signal.getsignal(signal.SIGINT)

	# Use our own SIGINT handler to be 100% sure this is working
	def custom_handler(signum, frame):
	pass

	signal.signal(signal.SIGINT, custom_handler)

	try:
	# mainloop() sets SIGINT, starts Qt event loop (which triggers timer
	# and exits) and then mainloop() resets SIGINT
	matplotlib.backends.backend_qt._BackendQT.mainloop()

	# Assert: signal handler during loop execution is changed
	# (can't test equality with func)
	assert event_loop_handler != custom_handler

	# Assert: current signal handler is the same as the one we set before
	assert signal.getsignal(signal.SIGINT) == custom_handler

	# Repeat again to test that SIG_DFL and SIG_IGN will not be overridden
	for custom_handler in (signal.SIG_DFL, signal.SIG_IGN):
	qt_core.QTimer.singleShot(0, fire_signal_and_quit)
	signal.signal(signal.SIGINT, custom_handler)

	_BackendQT5.mainloop()

	assert event_loop_handler == custom_handler
	assert signal.getsignal(signal.SIGINT) == custom_handler

	finally:
	# Reset SIGINT handler to what it was before the test
	signal.signal(signal.SIGINT, original_handler)


	@pytest.mark.backend('QtAgg', skip_on_importerror=True)
	def test_ipython():
	from matplotlib.testing import ipython_in_subprocess
	ipython_in_subprocess("qt", {(8, 24): "qtagg", (8, 15): "QtAgg", (7, 0): "Qt5Agg"})