Skip to content

armgit / manim

Public Imported from GitHub
0

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.py
index 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 self
def 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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_dir
diff --git a/tests/opengl/test_graph_opengl.py b/tests/opengl/test_graph_opengl.py
new file mode 100644
index 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.py
new file mode 100644
index 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_renderer
diff --git a/tests/opengl/test_markup_opengl.py b/tests/opengl/test_markup_opengl.py
new file mode 100644
index 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.py
new file mode 100644
index 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 scene
diff --git a/tests/opengl/test_texmobject_opengl.py b/tests/opengl/test_texmobject_opengl.py
new file mode 100644
index 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()
+
+
+ "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).height
diff --git a/tests/opengl/test_text_mobject_opengl.py b/tests/opengl/test_text_mobject_opengl.py
new file mode 100644
index 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.4
diff --git a/tests/opengl/test_ticks_opengl.py b/tests/opengl/test_ticks_opengl.py
new file mode 100644
index 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_range
diff --git a/tests/opengl/test_unit_geometry_opengl.py b/tests/opengl/test_unit_geometry_opengl.py
new file mode 100644
index 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.py
new file mode 100644
index 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