A community-maintained Python framework for creating mathematical animations.
Reuse cairo tests with opengl
Ryan McCauleyce07a50d82a1
diff --git a/manim/scene/scene.py b/manim/scene/scene.pyindex 99995bf6c..82dfa3ced 100644--- a/manim/scene/scene.py+++ b/manim/scene/scene.py@@ -421,7 +421,7 @@ class Scene:mobject_list_name="moving_mobjects",)self.moving_mobjects += mobjects- return self+ return selfdef add_mobjects_from_animations(self, animations):curr_mobjects = self.get_mobject_family_members()diff --git a/tests/opengl/test_animate_opengl.py b/tests/opengl/test_animate_opengl.pynew file mode 100644index 000000000..b30f727ab--- /dev/null+++ b/tests/opengl/test_animate_opengl.py@@ -0,0 +1,118 @@+import numpy as np+import pytest++from manim.animation.creation import Uncreate+from manim.mobject.geometry import Dot, Line, Square+from manim.mobject.mobject import override_animate+from manim.mobject.types.vectorized_mobject import VGroup+++def test_simple_animate(using_opengl_renderer):+ s = Square()+ scale_factor = 2+ anim = s.animate.scale(scale_factor).build()+ assert anim.mobject.target.width == scale_factor * s.width+++def test_chained_animate(using_opengl_renderer):+ s = Square()+ scale_factor = 2+ direction = np.array((1, 1, 0))+ anim = s.animate.scale(scale_factor).shift(direction).build()+ assert (+ anim.mobject.target.width == scale_factor * s.width+ and (anim.mobject.target.get_center() == direction).all()+ )+++def test_overridden_animate(using_opengl_renderer):+ class DotsWithLine(VGroup):+ def __init__(self):+ super().__init__()+ self.left_dot = Dot().shift((-1, 0, 0))+ self.right_dot = Dot().shift((1, 0, 0))+ self.line = Line(self.left_dot, self.right_dot)+ self.add(self.left_dot, self.right_dot, self.line)++ def remove_line(self):+ self.remove(self.line)++ @override_animate(remove_line)+ def _remove_line_animation(self, anim_args=None):+ if anim_args is None:+ anim_args = {}+ self.remove_line()+ return Uncreate(self.line, **anim_args)++ dots_with_line = DotsWithLine()+ anim = dots_with_line.animate.remove_line().build()+ assert len(dots_with_line.submobjects) == 2+ assert type(anim) is Uncreate+++def test_chaining_overridden_animate(using_opengl_renderer):+ class DotsWithLine(VGroup):+ def __init__(self):+ super().__init__()+ self.left_dot = Dot().shift((-1, 0, 0))+ self.right_dot = Dot().shift((1, 0, 0))+ self.line = Line(self.left_dot, self.right_dot)+ self.add(self.left_dot, self.right_dot, self.line)++ def remove_line(self):+ self.remove(self.line)++ @override_animate(remove_line)+ def _remove_line_animation(self, anim_args=None):+ if anim_args is None:+ anim_args = {}+ self.remove_line()+ return Uncreate(self.line, **anim_args)++ with pytest.raises(+ NotImplementedError,+ match="not supported for overridden animations",+ ):+ DotsWithLine().animate.shift((1, 0, 0)).remove_line()++ with pytest.raises(+ NotImplementedError,+ match="not supported for overridden animations",+ ):+ DotsWithLine().animate.remove_line().shift((1, 0, 0))+++def test_animate_with_args(using_opengl_renderer):+ s = Square()+ scale_factor = 2+ run_time = 2++ anim = s.animate(run_time=run_time).scale(scale_factor).build()+ assert anim.mobject.target.width == scale_factor * s.width+ assert anim.run_time == run_time+++def test_chained_animate_with_args(using_opengl_renderer):+ s = Square()+ scale_factor = 2+ direction = np.array((1, 1, 0))+ run_time = 2++ anim = s.animate(run_time=run_time).scale(scale_factor).shift(direction).build()+ assert (+ anim.mobject.target.width == scale_factor * s.width+ and (anim.mobject.target.get_center() == direction).all()+ )+ assert anim.run_time == run_time+++def test_animate_with_args_misplaced(using_opengl_renderer):+ s = Square()+ scale_factor = 2+ run_time = 2++ with pytest.raises(ValueError, match="must be passed before"):+ s.animate.scale(scale_factor)(run_time=run_time)++ with pytest.raises(ValueError, match="must be passed before"):+ s.animate(run_time=run_time)(run_time=run_time).scale(scale_factor)diff --git a/tests/opengl/test_axes_shift_opengl.py b/tests/opengl/test_axes_shift_opengl.pynew file mode 100644index 000000000..ec3fe90b5--- /dev/null+++ b/tests/opengl/test_axes_shift_opengl.py@@ -0,0 +1,9 @@+import numpy as np++from manim.mobject.coordinate_systems import Axes+++def test_axes_origin_shift(using_opengl_renderer):+ ax = Axes(x_range=(5, 10, 1), y_range=(40, 45, 0.5))+ assert np.allclose(ax.coords_to_point(5.0, 40.0), ax.x_axis.number_to_point(5))+ assert np.allclose(ax.coords_to_point(5.0, 40.0), ax.y_axis.number_to_point(40))diff --git a/tests/opengl/test_copy_opengl.py b/tests/opengl/test_copy_opengl.pynew file mode 100644index 000000000..ebef68897--- /dev/null+++ b/tests/opengl/test_copy_opengl.py@@ -0,0 +1,49 @@+from pathlib import Path++from manim import BraceLabel, config+from manim.mobject.opengl_mobject import OpenGLMobject+++def test_opengl_mobject_copy(using_opengl_renderer):+ """Test that a copy is a deepcopy."""+ orig = OpenGLMobject()+ orig.add(*(OpenGLMobject() for _ in range(10)))+ copy = orig.copy()++ assert orig is orig+ assert orig is not copy+ assert orig.submobjects is not copy.submobjects+ for i in range(10):+ assert orig.submobjects[i] is not copy.submobjects[i]+++def test_bracelabel_copy(using_opengl_renderer, tmp_path):+ """Test that a copy is a deepcopy."""+ # For this test to work, we need to tweak some folders temporarily+ original_text_dir = config["text_dir"]+ original_tex_dir = config["tex_dir"]+ mediadir = Path(tmp_path) / "deepcopy"+ config["text_dir"] = str(mediadir.joinpath("Text"))+ config["tex_dir"] = str(mediadir.joinpath("Tex"))+ for el in ["text_dir", "tex_dir"]:+ Path(config[el]).mkdir(parents=True)++ # Before the refactoring of OpenGLMobject.copy(), the class BraceLabel was the+ # only one to have a non-trivial definition of copy. Here we test that it+ # still works after the refactoring.+ orig = BraceLabel(OpenGLMobject(), "label")+ copy = orig.copy()++ assert orig is orig+ assert orig is not copy+ assert orig.brace is not copy.brace+ assert orig.label is not copy.label+ assert orig.submobjects is not copy.submobjects+ assert orig.submobjects[0] is orig.brace+ assert copy.submobjects[0] is copy.brace+ assert orig.submobjects[0] is not copy.brace+ assert copy.submobjects[0] is not orig.brace++ # Restore the original folders+ config["text_dir"] = original_text_dir+ config["tex_dir"] = original_tex_dirdiff --git a/tests/opengl/test_graph_opengl.py b/tests/opengl/test_graph_opengl.pynew file mode 100644index 000000000..f360bd73e--- /dev/null+++ b/tests/opengl/test_graph_opengl.py@@ -0,0 +1,98 @@+from manim import Dot, Graph, Line, Text+++def test_graph_creation(using_opengl_renderer):+ vertices = [1, 2, 3, 4]+ edges = [(1, 2), (2, 3), (3, 4), (4, 1)]+ layout = {1: [0, 0, 0], 2: [1, 1, 0], 3: [1, -1, 0], 4: [-1, 0, 0]}+ G_manual = Graph(vertices=vertices, edges=edges, layout=layout)+ assert len(G_manual.vertices) == 4+ assert len(G_manual.edges) == 4+ G_spring = Graph(vertices=vertices, edges=edges)+ assert len(G_spring.vertices) == 4+ assert len(G_spring.edges) == 4+++def test_graph_add_vertices(using_opengl_renderer):+ G = Graph([1, 2, 3], [(1, 2), (2, 3)])+ G.add_vertices(4)+ assert len(G.vertices) == 4+ assert len(G.edges) == 2+ G.add_vertices(5, labels={5: Text("5")})+ assert len(G.vertices) == 5+ assert len(G.edges) == 2+ assert 5 in G._labels+ assert 5 in G._vertex_config+ G.add_vertices(6, 7, 8)+ assert len(G.vertices) == 8+ assert len(G._graph.nodes()) == 8+++def test_graph_remove_vertices(using_opengl_renderer):+ G = Graph([1, 2, 3, 4, 5], [(1, 2), (2, 3), (3, 4), (4, 5)])+ removed_mobjects = G.remove_vertices(3)+ assert len(removed_mobjects) == 3+ assert len(G.vertices) == 4+ assert len(G.edges) == 2+ assert list(G.vertices.keys()) == [1, 2, 4, 5]+ assert list(G.edges.keys()) == [(1, 2), (4, 5)]+ removed_mobjects = G.remove_vertices(4, 5)+ assert len(removed_mobjects) == 3+ assert len(G.vertices) == 2+ assert len(G.edges) == 1+ assert list(G.vertices.keys()) == [1, 2]+ assert list(G.edges.keys()) == [(1, 2)]+++def test_graph_add_edges(using_opengl_renderer):+ G = Graph([1, 2, 3, 4, 5], [(1, 2), (2, 3)])+ added_mobjects = G.add_edges((1, 3))+ assert isinstance(added_mobjects.submobjects[0], Line)+ assert len(G.vertices) == 5+ assert len(G.edges) == 3+ assert set(G.vertices.keys()) == {1, 2, 3, 4, 5}+ assert set(G.edges.keys()) == {(1, 2), (2, 3), (1, 3)}++ added_mobjects = G.add_edges((1, 42))+ removed_mobjects = added_mobjects.submobjects+ assert isinstance(removed_mobjects[0], Dot)+ assert isinstance(removed_mobjects[1], Line)++ assert len(G.vertices) == 6+ assert len(G.edges) == 4+ assert set(G.vertices.keys()) == {1, 2, 3, 4, 5, 42}+ assert set(G.edges.keys()) == {(1, 2), (2, 3), (1, 3), (1, 42)}++ added_mobjects = G.add_edges((4, 5), (5, 6), (6, 7))+ assert len(added_mobjects) == 5+ assert len(G.vertices) == 8+ assert len(G.edges) == 7+ assert set(G.vertices.keys()) == {1, 2, 3, 4, 5, 42, 6, 7}+ assert set(G._graph.nodes()) == set(G.vertices.keys())+ assert set(G.edges.keys()) == {+ (1, 2),+ (2, 3),+ (1, 3),+ (1, 42),+ (4, 5),+ (5, 6),+ (6, 7),+ }+ assert set(G._graph.edges()) == set(G.edges.keys())+++def test_graph_remove_edges(using_opengl_renderer):+ G = Graph([1, 2, 3, 4, 5], [(1, 2), (2, 3), (3, 4), (4, 5), (1, 5)])+ removed_mobjects = G.remove_edges((1, 2))+ assert isinstance(removed_mobjects.submobjects[0], Line)+ assert len(G.vertices) == 5+ assert len(G.edges) == 4+ assert set(G.edges.keys()) == {(2, 3), (3, 4), (4, 5), (1, 5)}+ assert set(G._graph.edges()) == set(G.edges.keys())++ removed_mobjects = G.remove_edges((2, 3), (3, 4), (4, 5), (5, 1))+ assert len(removed_mobjects) == 4+ assert len(G.vertices) == 5+ assert len(G.edges) == 0+ assert set(G._graph.edges()) == set()+ assert set(G.edges.keys()) == set()diff --git a/tests/opengl/test_ipython_magic_opengl.py b/tests/opengl/test_ipython_magic_opengl.pynew file mode 100644index 000000000..81e63f0f9--- /dev/null+++ b/tests/opengl/test_ipython_magic_opengl.py@@ -0,0 +1,35 @@+import re++from manim import config, tempconfig+from manim.utils.ipython_magic import _generate_file_name+++def test_jupyter_file_naming():+ """Check the format of file names for jupyter"""+ scene_name = "SimpleScene"+ expected_pattern = r"[0-9a-zA-Z_]+[@_-]\d\d\d\d-\d\d-\d\d[@_-]\d\d-\d\d-\d\d"+ current_renderer = config.renderer+ with tempconfig({"scene_names": [scene_name], "renderer": "opengl"}):+ file_name = _generate_file_name()+ match = re.match(expected_pattern, file_name)+ assert scene_name in file_name, (+ "Expected file to contain " + scene_name + " but got " + file_name+ )+ assert match, "file name does not match expected pattern " + expected_pattern+ # needs manually set back to avoid issues across tests+ config.renderer = current_renderer+++def test_jupyter_file_output(tmp_path):+ """Check the jupyter file naming is valid and can be created"""+ scene_name = "SimpleScene"+ current_renderer = config.renderer+ with tempconfig({"scene_names": [scene_name], "renderer": "opengl"}):+ file_name = _generate_file_name()+ actual_path = tmp_path.with_name(file_name)+ with open(actual_path, "w") as outfile:+ outfile.write("")+ assert actual_path.exists()+ assert actual_path.is_file()+ # needs manually set back to avoid issues across tests+ config.renderer = current_rendererdiff --git a/tests/opengl/test_markup_opengl.py b/tests/opengl/test_markup_opengl.pynew file mode 100644index 000000000..7f9e86684--- /dev/null+++ b/tests/opengl/test_markup_opengl.py@@ -0,0 +1,46 @@+from manim import MarkupText+++def test_good_markup(using_opengl_renderer):+ """Test creation of valid :class:`MarkupText` object"""+ try:+ MarkupText("<b>foo</b>")+ MarkupText("foo")+ success = True+ except ValueError:+ success = False+ assert success, "'<b>foo</b>' and 'foo' should not fail validation"+++def test_special_tags_markup(using_opengl_renderer):+ """Test creation of valid :class:`MarkupText` object with unofficial tags"""+ try:+ MarkupText('<color col="RED">foo</color>')+ MarkupText('<gradient from="RED" to="YELLOW">foo</gradient>')+ success = True+ except ValueError:+ success = False+ assert (+ success+ ), '\'<color col="RED">foo</color>\' and \'<gradient from="RED" to="YELLOW">foo</gradient>\' should not fail validation'+++def test_unbalanced_tag_markup(using_opengl_renderer):+ """Test creation of invalid :class:`MarkupText` object (unbalanced tag)"""+ try:+ MarkupText("<b>foo")+ success = False+ except ValueError:+ success = True+ assert success, "'<b>foo' should fail validation"+++def test_invalid_tag_markup(using_opengl_renderer):+ """Test creation of invalid :class:`MarkupText` object (invalid tag)"""+ try:+ MarkupText("<invalidtag>foo</invalidtag>")+ success = False+ except ValueError:+ success = True++ assert success, "'<invalidtag>foo</invalidtag>' should fail validation"diff --git a/tests/opengl/test_scene_opengl.py b/tests/opengl/test_scene_opengl.pynew file mode 100644index 000000000..d69570268--- /dev/null+++ b/tests/opengl/test_scene_opengl.py@@ -0,0 +1,34 @@+from manim import Scene, tempconfig+from manim.mobject.opengl_mobject import OpenGLMobject+++def test_scene_add_remove(using_opengl_renderer):+ with tempconfig({"dry_run": True}):+ scene = Scene()+ assert len(scene.mobjects) == 0+ scene.add(OpenGLMobject())+ assert len(scene.mobjects) == 1+ scene.add(*(OpenGLMobject() for _ in range(10)))+ assert len(scene.mobjects) == 11++ # Check that adding a mobject twice does not actually add it twice+ repeated = OpenGLMobject()+ scene.add(repeated)+ assert len(scene.mobjects) == 12+ scene.add(repeated)+ assert len(scene.mobjects) == 12++ # Check that Scene.add() returns the Scene (for chained calls)+ assert scene.add(OpenGLMobject()) is scene+ to_remove = OpenGLMobject()+ scene = Scene()+ scene.add(to_remove)+ scene.add(*(OpenGLMobject() for _ in range(10)))+ assert len(scene.mobjects) == 11+ scene.remove(to_remove)+ assert len(scene.mobjects) == 10+ scene.remove(to_remove)+ assert len(scene.mobjects) == 10++ # Check that Scene.remove() returns the instance (for chained calls)+ assert scene.add(OpenGLMobject()) is scenediff --git a/tests/opengl/test_texmobject_opengl.py b/tests/opengl/test_texmobject_opengl.pynew file mode 100644index 000000000..118277db0--- /dev/null+++ b/tests/opengl/test_texmobject_opengl.py@@ -0,0 +1,107 @@+from pathlib import Path++import pytest++from manim import MathTex, SingleStringMathTex, Tex, config+++def test_MathTex(using_opengl_renderer):+ MathTex("a^2 + b^2 = c^2")+ assert Path(config.media_dir, "Tex", "3879f6b03bc495cd.svg").exists()+++def test_SingleStringMathTex(using_opengl_renderer):+ SingleStringMathTex("test")+ assert Path(config.media_dir, "Tex", "79822967f1fa1935.svg").exists()++[email protected]( # : PT006+ "text_input,length_sub",+ [("{{ a }} + {{ b }} = {{ c }}", 5), (r"\frac{1}{a+b\sqrt{2}}", 1)],+)+def test_double_braces_testing(using_opengl_renderer, text_input, length_sub):+ t1 = MathTex(text_input)+ assert len(t1.submobjects) == length_sub+++def test_tex(using_opengl_renderer):+ Tex("The horse does not eat cucumber salad.")+ assert Path(config.media_dir, "Tex", "983949cac5bdd272.svg").exists()+++def test_tex_whitespace_arg(using_opengl_renderer):+ """Check that correct number of submobjects are created per string with whitespace separator"""+ separator = "\t"+ str_part_1 = "Hello"+ str_part_2 = "world"+ str_part_3 = "It is"+ str_part_4 = "me!"+ tex = Tex(str_part_1, str_part_2, str_part_3, str_part_4, arg_separator=separator)+ assert len(tex) == 4+ assert len(tex[0]) == len("".join((str_part_1 + separator).split()))+ assert len(tex[1]) == len("".join((str_part_2 + separator).split()))+ assert len(tex[2]) == len("".join((str_part_3 + separator).split()))+ assert len(tex[3]) == len("".join(str_part_4.split()))+++def test_tex_non_whitespace_arg(using_opengl_renderer):+ """Check that correct number of submobjects are created per string with non_whitespace characters"""+ separator = ","+ str_part_1 = "Hello"+ str_part_2 = "world"+ str_part_3 = "It is"+ str_part_4 = "me!"+ tex = Tex(str_part_1, str_part_2, str_part_3, str_part_4, arg_separator=separator)+ assert len(tex) == 4+ assert len(tex[0]) == len("".join((str_part_1 + separator).split()))+ assert len(tex[1]) == len("".join((str_part_2 + separator).split()))+ assert len(tex[2]) == len("".join((str_part_3 + separator).split()))+ assert len(tex[3]) == len("".join(str_part_4.split()))+++def test_tex_white_space_and_non_whitespace_args(using_opengl_renderer):+ """Check that correct number of submobjects are created per string when mixing characters with whitespace"""+ separator = ", \n . \t\t"+ str_part_1 = "Hello"+ str_part_2 = "world"+ str_part_3 = "It is"+ str_part_4 = "me!"+ tex = Tex(str_part_1, str_part_2, str_part_3, str_part_4, arg_separator=separator)+ assert len(tex) == 4+ assert len(tex[0]) == len("".join((str_part_1 + separator).split()))+ assert len(tex[1]) == len("".join((str_part_2 + separator).split()))+ assert len(tex[2]) == len("".join((str_part_3 + separator).split()))+ assert len(tex[3]) == len("".join(str_part_4.split()))+++def test_tex_size(using_opengl_renderer):+ """Check that the size of a :class:`Tex` string is not changed."""+ text = Tex("what").center()+ vertical = text.get_top() - text.get_bottom()+ horizontal = text.get_right() - text.get_left()+ assert round(vertical[1], 4) == 0.3512+ assert round(horizontal[0], 4) == 1.0420+++def test_font_size(using_opengl_renderer):+ """Test that tex_mobject classes return+ the correct font_size value after being scaled."""+ string = MathTex(0).scale(0.3)++ assert round(string.font_size, 5) == 14.4+++def test_font_size_vs_scale(using_opengl_renderer):+ """Test that scale produces the same results as .scale()"""+ num = MathTex(0, font_size=12)+ num_scale = MathTex(0).scale(1 / 4)++ assert num.height == num_scale.height+++def test_changing_font_size(using_opengl_renderer):+ """Test that the font_size property properly scales tex_mobject.py classes."""+ num = Tex("0", font_size=12)+ num.font_size = 48++ assert num.height == Tex("0", font_size=48).heightdiff --git a/tests/opengl/test_text_mobject_opengl.py b/tests/opengl/test_text_mobject_opengl.pynew file mode 100644index 000000000..40799acf6--- /dev/null+++ b/tests/opengl/test_text_mobject_opengl.py@@ -0,0 +1,11 @@+from manim.mobject.svg.text_mobject import MarkupText, Text+++def test_font_size(using_opengl_renderer):+ """Test that Text and MarkupText return the+ correct font_size value after being scaled."""+ text_string = Text("0").scale(0.3)+ markuptext_string = MarkupText("0").scale(0.3)++ assert round(text_string.font_size, 5) == 14.4+ assert round(markuptext_string.font_size, 5) == 14.4diff --git a/tests/opengl/test_ticks_opengl.py b/tests/opengl/test_ticks_opengl.pynew file mode 100644index 000000000..714adc543--- /dev/null+++ b/tests/opengl/test_ticks_opengl.py@@ -0,0 +1,58 @@+import numpy as np++from manim import PI, Axes, NumberLine+++def test_duplicate_ticks_removed_for_axes(using_opengl_renderer):+ axis = NumberLine(+ x_range=[-10, 10],+ )+ ticks = axis.get_tick_range()+ assert np.unique(ticks).size == ticks.size+++def test_ticks_not_generated_on_origin_for_axes(using_opengl_renderer):+ axes = Axes(+ x_range=[-10, 10],+ y_range=[-10, 10],+ axis_config={"include_ticks": True},+ )++ x_axis_range = axes.x_axis.get_tick_range()+ y_axis_range = axes.y_axis.get_tick_range()++ assert 0 not in x_axis_range+ assert 0 not in y_axis_range+++def test_expected_ticks_generated(using_opengl_renderer):+ axes = Axes(x_range=[-2, 2], y_range=[-2, 2], axis_config={"include_ticks": True})+ x_axis_range = axes.x_axis.get_tick_range()+ y_axis_range = axes.y_axis.get_tick_range()++ assert 1 in x_axis_range+ assert 1 in y_axis_range+ assert -1 in x_axis_range+ assert -1 in y_axis_range+++def test_ticks_generated_from_origin_for_axes(using_opengl_renderer):+ axes = Axes(+ x_range=[-PI, PI],+ y_range=[-PI, PI],+ axis_config={"include_ticks": True},+ )+ x_axis_range = axes.x_axis.get_tick_range()+ y_axis_range = axes.y_axis.get_tick_range()++ assert -2 in x_axis_range+ assert -1 in x_axis_range+ assert 0 not in x_axis_range+ assert 1 in x_axis_range+ assert 2 in x_axis_range++ assert -2 in y_axis_range+ assert -1 in y_axis_range+ assert 0 not in y_axis_range+ assert 1 in y_axis_range+ assert 2 in y_axis_rangediff --git a/tests/opengl/test_unit_geometry_opengl.py b/tests/opengl/test_unit_geometry_opengl.pynew file mode 100644index 000000000..bfb49c1e2--- /dev/null+++ b/tests/opengl/test_unit_geometry_opengl.py@@ -0,0 +1,7 @@+import numpy as np++from manim import Sector+++def test_get_arc_center(using_opengl_renderer):+ assert np.all(Sector(arc_center=[1, 2, 0]).get_arc_center() == [1, 2, 0])diff --git a/tests/opengl/test_value_tracker_opengl.py b/tests/opengl/test_value_tracker_opengl.pynew file mode 100644index 000000000..e487acfe5--- /dev/null+++ b/tests/opengl/test_value_tracker_opengl.py@@ -0,0 +1,99 @@+from manim.mobject.value_tracker import ComplexValueTracker, ValueTracker+++def test_value_tracker_set_value(using_opengl_renderer):+ """Test ValueTracker.set_value()"""+ tracker = ValueTracker()+ tracker.set_value(10.0)+ assert tracker.get_value() == 10.0+++def test_value_tracker_get_value(using_opengl_renderer):+ """Test ValueTracker.get_value()"""+ tracker = ValueTracker(10.0)+ assert tracker.get_value() == 10.0+++def test_value_tracker_interpolate(using_opengl_renderer):+ """Test ValueTracker.interpolate()"""+ tracker1 = ValueTracker(1.0)+ tracker2 = ValueTracker(2.5)+ tracker3 = ValueTracker().interpolate(tracker1, tracker2, 0.7)+ assert tracker3.get_value() == 2.05+++def test_value_tracker_increment_value(using_opengl_renderer):+ """Test ValueTracker.increment_value()"""+ tracker = ValueTracker(0.0)+ tracker.increment_value(10.0)+ assert tracker.get_value() == 10.0+++def test_value_tracker_bool(using_opengl_renderer):+ """Test ValueTracker.__bool__()"""+ tracker = ValueTracker(0.0)+ assert not tracker+ tracker.increment_value(1.0)+ assert tracker+++def test_value_tracker_iadd(using_opengl_renderer):+ """Test ValueTracker.__iadd__()"""+ tracker = ValueTracker(0.0)+ tracker += 10.0+ assert tracker.get_value() == 10.0+++def test_value_tracker_ifloordiv(using_opengl_renderer):+ """Test ValueTracker.__ifloordiv__()"""+ tracker = ValueTracker(5.0)+ tracker //= 2.0+ assert tracker.get_value() == 2.0+++def test_value_tracker_imod(using_opengl_renderer):+ """Test ValueTracker.__imod__()"""+ tracker = ValueTracker(20.0)+ tracker %= 3.0+ assert tracker.get_value() == 2.0+++def test_value_tracker_imul(using_opengl_renderer):+ """Test ValueTracker.__imul__()"""+ tracker = ValueTracker(3.0)+ tracker *= 4.0+ assert tracker.get_value() == 12.0+++def test_value_tracker_ipow(using_opengl_renderer):+ """Test ValueTracker.__ipow__()"""+ tracker = ValueTracker(3.0)+ tracker **= 3.0+ assert tracker.get_value() == 27.0+++def test_value_tracker_isub(using_opengl_renderer):+ """Test ValueTracker.__isub__()"""+ tracker = ValueTracker(20.0)+ tracker -= 10.0+ assert tracker.get_value() == 10.0+++def test_value_tracker_itruediv(using_opengl_renderer):+ """Test ValueTracker.__itruediv__()"""+ tracker = ValueTracker(5.0)+ tracker /= 2.0+ assert tracker.get_value() == 2.5+++def test_complex_value_tracker_set_value(using_opengl_renderer):+ """Test ComplexValueTracker.set_value()"""+ tracker = ComplexValueTracker()+ tracker.set_value(1 + 2j)+ assert tracker.get_value() == 1 + 2j+++def test_complex_value_tracker_get_value(using_opengl_renderer):+ """Test ComplexValueTracker.get_value()"""+ tracker = ComplexValueTracker(2.0 - 3.0j)+ assert tracker.get_value() == 2.0 - 3.0j