leanplot 1.0.0__py3-none-any.whl

leanplot/core/mixin.py

@@ -0,0 +1,187 @@
+#  ------------------------------------------------------------------------------
+#  Copyright (c) 2026 Joel Kimmich
+#  ------------------------------------------------------------------------------
+#  License
+#      This file is part of LeanPlot, distributed under MIT license.
+#  ------------------------------------------------------------------------------
+#
+from datetime import datetime
+
+import matplotlib.ticker as ticker
+from matplotlib import pyplot as plt
+
+from leanplot.core.colors.categorical import ColorPalette
+from leanplot.core.functions import cm_to_inch, custom_numeric_ticks_formatter, format_date_x_axis
+
+
+class PlotMixin(object):
+    def __init__(
+        self,
+        x,
+        ys,
+        y_title="Title / Unit",
+        marker_size=6,
+        x_title=None,
+        width_mm=160,
+        height_mm=90,
+        iter_color_and_style_together: bool = False,
+        iter_color_first: bool = True,
+        color_palette: ColorPalette | str | None = None,
+    ):
+        self.fig, self.ax = plt.subplots(layout="constrained")
+        self.fig.set_size_inches(cm_to_inch(width_mm / 10), cm_to_inch(height_mm / 10))
+
+        if color_palette is None:
+            color_palette = ColorPalette()
+        elif isinstance(color_palette, str):
+            color_palette = ColorPalette(color_palette)
+        else:
+            assert isinstance(color_palette, ColorPalette)
+        self.colors = color_palette.colors
+        self.styles = ["-", "--", ":", "-."]
+        self.markers = ["o", "s", "^", "v", "<", ">", "d", "p", "*", "h"]
+
+        self.x = x
+        self.ys = ys
+
+        if isinstance(self.x[0], datetime):
+            self.x_is_datetime = True
+        else:
+            self.x_is_datetime = False
+
+        self.y_title = y_title
+        self.x_title = x_title
+        self.marker_size = marker_size
+
+        self.lines = None
+        self.labels = []
+
+        self.iter_color_and_style_together = iter_color_and_style_together
+        self.iter_color_first = iter_color_first
+
+        self.next_color = self.color_iter()
+        self.next_line_style = self.line_style_iter()
+        self.next_marker = self.marker_iter()
+
+    def __del__(self):
+        try:
+            if self.fig is not None:
+                plt.close(self.fig)
+        except AttributeError:
+            pass
+
+    def marker_iter(self):
+        markers = self.markers
+        n_markers = len(markers)
+        n = len(self.colors)
+        i = 0
+        if self.iter_color_and_style_together or not self.iter_color_first:
+            while True:
+                yield markers[i]
+                i = (i + 1) % n_markers
+        else:
+            while True:
+                yield markers[i // n]
+                i += 1
+                if i >= n * n_markers:
+                    i = 0
+
+    def line_style_iter(self):
+        n = len(self.colors)
+        styles = self.styles
+        n_styles = len(styles)
+        i = 0
+        if self.iter_color_and_style_together or not self.iter_color_first:
+            while True:
+                yield styles[i]
+                i = (i + 1) % n_styles
+        else:
+            while True:
+                yield styles[i // n]
+                i += 1
+                if i >= n * n_styles:
+                    i = 0
+
+    def color_iter(self):
+        colors = self.colors
+        i = 0
+        n = len(colors)
+        n_styles = len(self.styles)
+        if self.iter_color_and_style_together or self.iter_color_first:
+            while True:
+                yield tuple(colors[i])
+                i = (i + 1) % n
+        else:
+            while True:
+                yield tuple(colors[i // n_styles])
+                i += 1
+                if i >= n_styles * n:
+                    i = 0
+
+    def _add_line(self, line):
+        if self.lines is None:
+            self.lines = line
+        else:
+            self.lines = self.lines + line
+
+    def _add_line_and_label(self, line, label=None):
+        if self.lines is None:
+            self.lines = line
+        else:
+            self.lines = self.lines + line
+        self.labels.append(label)
+
+    def format(self):
+        if self.x_title is not None:
+            self.ax.set_xlabel(self.x_title)
+        if self.y_title is not None:
+            self.ax.set_ylabel(self.y_title)
+        self.ax.grid(True)
+        self.ax.set_xlim(left=self.x[0], right=self.x[-1])
+        if self.x_is_datetime:
+            self.formate_x_datetime()
+
+    def formate_x_datetime(self, start=None, end=None):
+        if start is None:
+            start = self.x[0]
+        if end is None:
+            end = self.x[-1]
+        format_date_x_axis(start, end, self.ax, return_version=False)
+
+    def format_numeric_ticks(self):
+        formatter = ticker.FuncFormatter(custom_numeric_ticks_formatter)
+
+        for ax in self.fig.get_axes():
+            # Check if y-axis has numeric data
+            try:
+                current_formatter = ax.yaxis.get_major_formatter()
+                if not isinstance(current_formatter, plt.matplotlib.dates.DateFormatter):
+                    ax.yaxis.set_major_formatter(formatter)
+            except:
+                pass
+
+            # Check x-axis
+            if not self.x_is_datetime and not isinstance(self.x[0], str):
+                try:
+                    current_formatter = ax.xaxis.get_major_formatter()
+                    if not isinstance(current_formatter, plt.matplotlib.dates.DateFormatter):
+                        ax.xaxis.set_major_formatter(formatter)
+                except:
+                    pass
+
+    def show_legend(self, **kwargs):
+        initial_kwargs = {"loc": "outside upper right", "ncols": min(4, len(self.labels))}
+        initial_kwargs.update(kwargs)
+        self.fig.legend(handles=self.lines, labels=self.labels, **initial_kwargs)
+
+    def show(self):
+        self.format_numeric_ticks()
+        plt.show()
+
+    def save(self, path):
+        self.format_numeric_ticks()
+        self.fig.savefig(path, dpi=600)
+
+    def close(self):
+        if self.fig is not None:
+            plt.close(self.fig)

leanplot/tests/__init__.py

@@ -0,0 +1,8 @@
+#  ------------------------------------------------------------------------------
+#  Copyright (c) 2026 Joel Kimmich
+#  ------------------------------------------------------------------------------
+#  License
+#      This file is part of LeanPlot, distributed under MIT license.
+#  ------------------------------------------------------------------------------
+#
+

leanplot/tests/test_categorical.py

@@ -0,0 +1,64 @@
+#  ------------------------------------------------------------------------------
+#  Copyright (c) 2026 Joel Kimmich
+#  ------------------------------------------------------------------------------
+#  License
+#      This file is part of LeanPlot, distributed under MIT license.
+#  ------------------------------------------------------------------------------
+#
+from unittest import TestCase
+
+import cmcrameri.cm as cmc
+
+from leanplot.core.colors.categorical import ColorPalette
+
+
+class TestColorPalette(TestCase):
+    def test_default_initialization_uses_batlow_with_ten_colors(self):
+        """Verify that default parameters select the batlow colormap with ten colors."""
+        color_palette = ColorPalette()
+        self.assertEqual(color_palette.colormap_name, "oslo")
+        self.assertEqual(color_palette.number_of_colors, 5)
+
+    def test_colors_returns_requested_number_of_colors(self):
+        """Verify that the colors property returns exactly number_of_colors entries."""
+        color_palette = ColorPalette(colormap_name="batlow", number_of_colors=6)
+        self.assertEqual(len(color_palette.colors), 6)
+
+    def test_colors_returns_rgb_tuples_with_three_components(self):
+        """Verify that each returned color is a tuple of three components."""
+        color_palette = ColorPalette(colormap_name="batlow", number_of_colors=4)
+        for color in color_palette.colors:
+            self.assertEqual(len(color), 3)
+
+    def test_colors_components_are_within_valid_range(self):
+        """Verify that each color component lies within the closed interval [0, 1]."""
+        color_palette = ColorPalette(colormap_name="batlow", number_of_colors=10)
+        for color in color_palette.colors:
+            for component in color:
+                self.assertGreaterEqual(component, 0.0)
+                self.assertLessEqual(component, 1.0)
+
+    def test_colors_match_source_categorical_colormap(self):
+        """Verify that returned colors match the first entries of the underlying categorical colormap."""
+        color_palette = ColorPalette(colormap_name="oslo", number_of_colors=3)
+        expected_colors = [tuple(color[:3]) for color in cmc.osloS.colors[:3]]
+        self.assertEqual(color_palette.colors, expected_colors)
+
+    def test_invalid_colormap_name_raises_attribute_error(self):
+        """Verify that an unknown colormap name raises an AttributeError."""
+        color_palette = ColorPalette(colormap_name="not_a_real_colormap", number_of_colors=5)
+        with self.assertRaises(AttributeError):
+            _ = color_palette.colors
+
+    def test_number_of_colors_exceeding_available_raises_value_error(self):
+        """Verify that requesting more colors than available raises a ValueError."""
+        available_color_count = len(cmc.batlowS.colors)
+        color_palette = ColorPalette(colormap_name="batlow", number_of_colors=available_color_count + 1)
+        with self.assertRaises(ValueError):
+            _ = color_palette.colors
+
+    def test_number_of_colors_equal_to_available_does_not_raise(self):
+        """Verify that requesting exactly the available number of colors succeeds without error."""
+        available_color_count = len(cmc.batlowS.colors)
+        color_palette = ColorPalette(colormap_name="batlow", number_of_colors=available_color_count)
+        self.assertEqual(len(color_palette.colors), available_color_count)

leanplot/tests/test_line.py

@@ -0,0 +1,192 @@
+#  ------------------------------------------------------------------------------
+#  Copyright (c) 2026 Joel Kimmich
+#  ------------------------------------------------------------------------------
+#  License
+#      This file is part of LeanPlot, distributed under MIT license.
+#  ------------------------------------------------------------------------------
+#
+from unittest import TestCase
+from unittest.mock import MagicMock
+
+import numpy as np
+
+from leanplot.core.line import LinePlot, TimePlot
+
+
+class TestLinePlot(TestCase):
+    def setUp(self):
+        """Create shared x values and y series used across most LinePlot tests."""
+        self.x_values = [0, 1, 2, 3, 4]
+        self.single_y_series = [1, 2, 3, 4, 5]
+
+    def tearDown(self):
+        """Close the figure created during each test to avoid lingering matplotlib state."""
+        if hasattr(self, "line_plot"):
+            self.line_plot.close()
+
+    def test_initialization_wraps_single_list_y_into_one_series(self):
+        """Verify that a flat list of y values is wrapped into a single-element series list."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.assertEqual(len(self.line_plot.ys), 1)
+        np.testing.assert_array_equal(self.line_plot.ys[0], np.array(self.single_y_series))
+
+    def test_initialization_wraps_single_one_dimensional_array_into_one_series(self):
+        """Verify that a one-dimensional ndarray of y values is wrapped into a single-element series list."""
+        self.line_plot = LinePlot(x=self.x_values, ys=np.array(self.single_y_series))
+        self.assertEqual(len(self.line_plot.ys), 1)
+        np.testing.assert_array_equal(self.line_plot.ys[0], np.array(self.single_y_series))
+
+    def test_initialization_keeps_list_of_arrays_as_multiple_series(self):
+        """Verify that a list containing multiple y series is kept as multiple series."""
+        multiple_y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.line_plot = LinePlot(x=self.x_values, ys=multiple_y_series)
+        self.assertEqual(len(self.line_plot.ys), 2)
+
+    def test_initialization_keeps_two_dimensional_array_as_multiple_series(self):
+        """Verify that a two-dimensional ndarray with multiple rows is kept as multiple series."""
+        two_dimensional_y_series = np.array([[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]])
+        self.line_plot = LinePlot(x=self.x_values, ys=two_dimensional_y_series)
+        self.assertEqual(len(self.line_plot.ys), 2)
+
+    def test_initialization_default_labels_are_none_for_each_series(self):
+        """Verify that omitting labels results in a None label for every series."""
+        multiple_y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.line_plot = LinePlot(x=self.x_values, ys=multiple_y_series)
+        self.assertEqual(self.line_plot.labels, [None, None])
+
+    def test_initialization_wraps_single_label_string_into_list(self):
+        """Verify that a single label string is wrapped into a one-element list."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series, labels="Series One")
+        self.assertEqual(self.line_plot.labels, ["Series One"])
+
+    def test_initialization_sets_y_scale_and_line_width_attributes(self):
+        """Verify that y_scale and linewidth constructor arguments are stored correctly."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series, y_scale=2.0, linewidth=3.5)
+        self.assertEqual(self.line_plot.y_scale, 2.0)
+        self.assertEqual(self.line_plot.line_width, 3.5)
+
+    def test_plot_adds_one_line_per_series(self):
+        """Verify that plot() adds exactly one line per y series."""
+        multiple_y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.line_plot = LinePlot(x=self.x_values, ys=multiple_y_series)
+        self.line_plot.plot()
+        self.assertEqual(len(self.line_plot.lines), 2)
+
+    def test_plot_applies_y_scale_to_plotted_values(self):
+        """Verify that plot() multiplies the y values by y_scale before plotting."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series, y_scale=2.0)
+        self.line_plot.ax.plot = MagicMock(return_value=[MagicMock()])
+        self.line_plot.plot()
+        plotted_y_values = self.line_plot.ax.plot.call_args[0][1]
+        np.testing.assert_array_equal(plotted_y_values, np.array(self.single_y_series) * 2.0)
+
+    def test_plot_uses_instance_x_and_ys_when_not_provided(self):
+        """Verify that plot() defaults to self.x and self.ys when no arguments are given."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.ax.plot = MagicMock(return_value=[MagicMock()])
+        self.line_plot.plot()
+        plotted_x_values = self.line_plot.ax.plot.call_args[0][0]
+        np.testing.assert_array_equal(plotted_x_values, np.array(self.x_values))
+
+    def test_plot_calls_format(self):
+        """Verify that plot() calls format() after adding the lines."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format = MagicMock()
+        self.line_plot.plot()
+        self.line_plot.format.assert_called_once()
+
+    def test_add_points_adds_one_line_per_point_group(self):
+        """Verify that add_points() adds one line per group of point values."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        point_y_values = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]]
+        self.line_plot.add_points(x=self.x_values, ys=point_y_values, labels=["A", "B"])
+        self.assertEqual(len(self.line_plot.lines), 2)
+        self.assertEqual(self.line_plot.labels, [None, "A", "B"])
+
+    def test_add_points_wraps_single_label_into_list(self):
+        """Verify that add_points() wraps a single label string into a one-element list."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.add_points(x=self.x_values, ys=self.single_y_series, labels="Measurements")
+        self.assertEqual(self.line_plot.labels, [None, "Measurements"])
+
+    def test_add_points_raises_assertion_error_on_label_count_mismatch(self):
+        """Verify that add_points() raises an AssertionError when labels and ys lengths differ."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        point_y_values = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6]]
+        with self.assertRaises(AssertionError):
+            self.line_plot.add_points(x=self.x_values, ys=point_y_values, labels=["A"])
+
+    def test_add_points_does_not_apply_y_scale(self):
+        """Verify that add_points() plots the raw y values without applying y_scale."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series, y_scale=2.0)
+        self.line_plot.ax.plot = MagicMock(return_value=[MagicMock()])
+        self.line_plot.add_points(x=self.x_values, ys=self.single_y_series)
+        plotted_y_values = self.line_plot.ax.plot.call_args[0][1]
+        np.testing.assert_array_equal(plotted_y_values, np.array(self.single_y_series))
+
+    def test_add_points_calls_format(self):
+        """Verify that add_points() calls format() after adding the point lines."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format = MagicMock()
+        self.line_plot.add_points(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format.assert_called_once()
+
+    def test_plot_marker_adds_one_plot_call_per_series(self):
+        """Verify that plot_marker() issues one ax.plot call per y series with a marker set."""
+        multiple_y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.line_plot = LinePlot(x=self.x_values, ys=multiple_y_series)
+        self.line_plot.ax.plot = MagicMock(return_value=[MagicMock()])
+        self.line_plot.plot_marker()
+        self.assertEqual(self.line_plot.ax.plot.call_count, 2)
+        for call in self.line_plot.ax.plot.call_args_list:
+            self.assertIn("marker", call.kwargs)
+
+    def test_plot_marker_calls_format(self):
+        """Verify that plot_marker() calls format() after plotting the markers."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format = MagicMock()
+        self.line_plot.plot_marker()
+        self.line_plot.format.assert_called_once()
+
+    def test_plot_stack_calls_stackplot_with_labels_and_colors(self):
+        """Verify that plot_stack() calls ax.stackplot with the instance labels and colors."""
+        multiple_y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.line_plot = LinePlot(x=self.x_values, ys=multiple_y_series, labels=["A", "B"])
+        self.line_plot.ax.stackplot = MagicMock()
+        self.line_plot.plot_stack()
+        _, call_kwargs = self.line_plot.ax.stackplot.call_args
+        self.assertEqual(call_kwargs["labels"], ["A", "B"])
+        self.assertEqual(call_kwargs["colors"], self.line_plot.colors)
+
+    def test_plot_stack_calls_format(self):
+        """Verify that plot_stack() calls format() after stacking the series."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format = MagicMock()
+        self.line_plot.plot_stack()
+        self.line_plot.format.assert_called_once()
+
+    def test_format_calls_format_numeric_ticks(self):
+        """Verify that format() calls format_numeric_ticks() in addition to the base format logic."""
+        self.line_plot = LinePlot(x=self.x_values, ys=self.single_y_series)
+        self.line_plot.format_numeric_ticks = MagicMock()
+        self.line_plot.format()
+        self.line_plot.format_numeric_ticks.assert_called_once()
+
+
+class TestTimePlot(TestCase):
+    def setUp(self):
+        """Create shared x and y values used across TimePlot tests."""
+        self.x_values = [0, 1, 2, 3, 4]
+        self.y_values = [1, 2, 3, 4, 5]
+
+    def tearDown(self):
+        """Close the figure created during each test to avoid lingering matplotlib state."""
+        self.time_plot.close()
+
+    def test_format_calls_formate_x_datetime_and_format_numeric_ticks(self):
+        """Verify that format() calls both formate_x_datetime() and format_numeric_ticks()."""
+        self.time_plot = TimePlot(x=self.x_values, ys=self.y_values)
+        self.time_plot.formate_x_datetime = MagicMock()
+        self.time_plot.format_numeric_ticks = MagicMock()
+        self.time_plot.format()
+        self.time_plot.formate_x_datetime.assert_called_once()

leanplot/tests/test_mixin.py

@@ -0,0 +1,208 @@
+#  ------------------------------------------------------------------------------
+#  Copyright (c) 2026 Joel Kimmich
+#  ------------------------------------------------------------------------------
+#  License
+#      This file is part of LeanPlot, distributed under MIT license.
+#  ------------------------------------------------------------------------------
+#
+
+from datetime import datetime
+from unittest import TestCase
+from unittest.mock import MagicMock, patch
+
+from leanplot.core.colors.categorical import ColorPalette
+from leanplot.core.mixin import PlotMixin
+
+
+class TestPlotMixin(TestCase):
+    def setUp(self):
+        """Create a default numeric PlotMixin instance shared by most tests."""
+        self.numeric_x_values = [1, 2, 3, 4, 5]
+        self.y_series = [[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series)
+
+    def tearDown(self):
+        """Close the figure created during each test to avoid lingering matplotlib state."""
+        self.plot_mixin.close()
+
+    def test_initialization_sets_default_color_palette_when_none_provided(self):
+        """Verify that omitting color_palette falls back to the default ColorPalette colors."""
+        expected_colors = ColorPalette().colors
+        self.assertEqual(self.plot_mixin.colors, expected_colors)
+
+    def test_initialization_uses_provided_color_palette(self):
+        """Verify that a custom ColorPalette instance is applied instead of the default one."""
+        custom_color_palette = ColorPalette(colormap_name="buda", number_of_colors=3)
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, color_palette=custom_color_palette)
+        self.assertEqual(self.plot_mixin.colors, custom_color_palette.colors)
+
+    def test_initialization_creates_color_palette_from_string_colormap_name(self):
+        """Verify that passing a colormap name as a string creates a matching ColorPalette."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, color_palette="hawaii")
+        expected_colors = ColorPalette("hawaii").colors
+        self.assertEqual(self.plot_mixin.colors, expected_colors)
+
+    def test_initialization_raises_assertion_error_for_invalid_color_palette_type(self):
+        """Verify that passing a color_palette that is neither None, a string, nor a ColorPalette raises an error."""
+        with self.assertRaises(AssertionError):
+            self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, color_palette=42)
+
+    def test_initialization_detects_datetime_x_axis(self):
+        """Verify that x_is_datetime is True when the x values are datetime objects."""
+        datetime_x_values = [datetime(2026, 1, 1), datetime(2026, 1, 2), datetime(2026, 1, 3)]
+        self.plot_mixin = PlotMixin(x=datetime_x_values, ys=self.y_series)
+        self.assertTrue(self.plot_mixin.x_is_datetime)
+
+    def test_initialization_detects_non_datetime_x_axis(self):
+        """Verify that x_is_datetime is False when the x values are numeric."""
+        self.assertFalse(self.plot_mixin.x_is_datetime)
+
+    def test_markers_property_returns_expected_marker_list(self):
+        """Verify that the markers property returns the fixed list of marker symbols."""
+        expected_markers = ["o", "s", "^", "v", "<", ">", "d", "p", "*", "h"]
+        self.assertEqual(self.plot_mixin.markers, expected_markers)
+
+    def test_marker_iter_cycles_back_to_first_marker(self):
+        """Verify that marker_iter wraps around to the first marker after exhausting the list."""
+
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, iter_color_first=False)
+        markers = self.plot_mixin.markers
+        marker_generator = self.plot_mixin.marker_iter()
+        produced_markers = [next(marker_generator) for _ in range(len(markers) + 1)]
+        self.assertEqual(produced_markers[0], produced_markers[-1])
+        self.assertEqual(produced_markers[:-1], markers)
+
+    def test_color_iter_cycles_back_to_first_color(self):
+        """Verify that color_iter wraps around to the first color after exhausting the palette."""
+        colors = self.plot_mixin.colors
+        color_generator = self.plot_mixin.color_iter()
+        produced_colors = [next(color_generator) for _ in range(len(colors) + 1)]
+        self.assertEqual(produced_colors[0], produced_colors[-1])
+        self.assertEqual(produced_colors[:-1], [tuple(color) for color in colors])
+
+    def test_line_style_iter_starts_with_solid_style(self):
+        """Verify that line_style_iter begins with the solid line style for the first color."""
+        line_style_generator = self.plot_mixin.line_style_iter()
+        first_style = next(line_style_generator)
+        self.assertEqual(first_style, "-")
+
+    def test_line_style_iter_switches_style_after_one_full_color_cycle(self):
+        """Verify that line_style_iter switches to the next style after cycling through all colors."""
+        number_of_colors = len(self.plot_mixin.colors)
+        line_style_generator = self.plot_mixin.line_style_iter()
+        produced_styles = [next(line_style_generator) for _ in range(number_of_colors + 1)]
+        self.assertEqual(produced_styles[:number_of_colors], ["-"] * number_of_colors)
+        self.assertEqual(produced_styles[number_of_colors], "--")
+
+    def test_add_line_initializes_lines_when_empty(self):
+        """Verify that _add_line sets self.lines when no lines have been added yet."""
+        plotted_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[0])
+        self.plot_mixin._add_line(plotted_line)
+        self.assertEqual(self.plot_mixin.lines, plotted_line)
+
+    def test_add_line_appends_to_existing_lines(self):
+        """Verify that _add_line concatenates new lines onto previously added lines."""
+        first_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[0])
+        second_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[1])
+        self.plot_mixin._add_line(first_line)
+        self.plot_mixin._add_line(second_line)
+        self.assertEqual(self.plot_mixin.lines, first_line + second_line)
+
+    def test_add_line_and_label_appends_label(self):
+        """Verify that _add_line_and_label appends the given label to self.labels."""
+        plotted_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[0])
+        self.plot_mixin._add_line_and_label(plotted_line, label="Series One")
+        self.assertEqual(self.plot_mixin.labels, ["Series One"])
+
+    def test_format_sets_axis_labels_when_titles_provided(self):
+        """Verify that format() applies x_title and y_title to the axis labels."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, x_title="Time / s", y_title="Value / "
+                                                                                                          "unit")
+        self.plot_mixin.format()
+        self.assertEqual(self.plot_mixin.ax.get_xlabel(), "Time / s")
+        self.assertEqual(self.plot_mixin.ax.get_ylabel(), "Value / unit")
+
+    def test_format_sets_x_limits_to_first_and_last_x_value(self):
+        """Verify that format() sets the x axis limits to the first and last x values."""
+        self.plot_mixin.format()
+        left_limit, right_limit = self.plot_mixin.ax.get_xlim()
+        self.assertEqual(left_limit, self.numeric_x_values[0])
+        self.assertEqual(right_limit, self.numeric_x_values[-1])
+
+    def test_format_calls_datetime_formatting_when_x_is_datetime(self):
+        """Verify that format() invokes formate_x_datetime when x values are datetime objects."""
+        datetime_x_values = [datetime(2026, 1, 1), datetime(2026, 1, 2), datetime(2026, 1, 3)]
+        self.plot_mixin = PlotMixin(x=datetime_x_values, ys=self.y_series)
+        self.plot_mixin.formate_x_datetime = MagicMock()
+        self.plot_mixin.format()
+        self.plot_mixin.formate_x_datetime.assert_called_once()
+
+    def test_show_legend_uses_default_number_of_columns(self):
+        """Verify that show_legend caps the column count at four when more labels are present."""
+        for index in range(5):
+            plotted_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[0])
+            self.plot_mixin._add_line_and_label(plotted_line, label=f"Series {index}")
+        self.plot_mixin.fig.legend = MagicMock()
+        self.plot_mixin.show_legend()
+        _, call_kwargs = self.plot_mixin.fig.legend.call_args
+        self.assertEqual(call_kwargs["ncols"], 4)
+
+    def test_show_legend_overrides_default_kwargs(self):
+        """Verify that explicit keyword arguments override the default show_legend settings."""
+        plotted_line = self.plot_mixin.ax.plot(self.numeric_x_values, self.y_series[0])
+        self.plot_mixin._add_line_and_label(plotted_line, label="Series One")
+        self.plot_mixin.fig.legend = MagicMock()
+        self.plot_mixin.show_legend(loc="lower left")
+        _, call_kwargs = self.plot_mixin.fig.legend.call_args
+        self.assertEqual(call_kwargs["loc"], "lower left")
+
+    def test_save_calls_savefig_with_given_path_and_dpi(self):
+        """Verify that save() calls fig.savefig with the given path and a dpi of 600."""
+        self.plot_mixin.fig.savefig = MagicMock()
+        self.plot_mixin.save("output.png")
+        self.plot_mixin.fig.savefig.assert_called_once_with("output.png", dpi=600)
+
+    @patch("matplotlib.pyplot.close")
+    def test_close_closes_the_figure(self, mock_plt_close):
+        """Verify that close() calls plt.close on the mixin's figure."""
+        figure_reference = self.plot_mixin.fig
+        self.plot_mixin.close()
+        mock_plt_close.assert_called_once_with(figure_reference)
+
+    def test_color_iter_advances_every_call_when_iter_color_and_style_together(self):
+        """Verify that color_iter cycles through every color on each call when colors and styles iterate together."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, iter_color_and_style_together=True)
+        colors = self.plot_mixin.colors
+        color_generator = self.plot_mixin.color_iter()
+        produced_colors = [next(color_generator) for _ in range(len(colors) + 1)]
+        self.assertEqual(produced_colors[:-1], [tuple(color) for color in colors])
+        self.assertEqual(produced_colors[0], produced_colors[-1])
+
+    def test_line_style_iter_advances_every_call_when_iter_color_and_style_together(self):
+        """Verify that line_style_iter cycles through every style on each call when colors and styles iterate together."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, iter_color_and_style_together=True)
+        styles = self.plot_mixin.styles
+        line_style_generator = self.plot_mixin.line_style_iter()
+        produced_styles = [next(line_style_generator) for _ in range(len(styles) + 1)]
+        self.assertEqual(produced_styles[:-1], styles)
+        self.assertEqual(produced_styles[0], produced_styles[-1])
+
+    def test_line_style_iter_advances_every_call_when_iter_color_first_is_false(self):
+        """Verify that line_style_iter cycles through every style on each call when styles are iterated first."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, iter_color_first=False)
+        styles = self.plot_mixin.styles
+        line_style_generator = self.plot_mixin.line_style_iter()
+        produced_styles = [next(line_style_generator) for _ in range(len(styles) + 1)]
+        self.assertEqual(produced_styles[:-1], styles)
+        self.assertEqual(produced_styles[0], produced_styles[-1])
+
+    def test_color_iter_switches_color_after_one_full_style_cycle_when_iter_color_first_is_false(self):
+        """Verify that color_iter switches to the next color only after cycling through all styles."""
+        self.plot_mixin = PlotMixin(x=self.numeric_x_values, ys=self.y_series, iter_color_first=False)
+        number_of_styles = len(self.plot_mixin.styles)
+        color_generator = self.plot_mixin.color_iter()
+        first_color = self.plot_mixin.colors[0]
+        second_color = self.plot_mixin.colors[1]
+        produced_colors = [next(color_generator) for _ in range(number_of_styles + 1)]
+        self.assertEqual(produced_colors[:number_of_styles], [tuple(first_color)] * number_of_styles)
+        self.assertEqual(produced_colors[number_of_styles], tuple(second_color))