psychopy 2025.2.4__py3-none-any.whl

psychopy/tests/test_experiment/test_components/test_GratingComponent.py

@@ -0,0 +1,7 @@
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestLibraryClassMixin
+from psychopy.experiment.components.grating import GratingComponent
+from psychopy.visual import GratingStim
+
+class TestGratingComponent(BaseComponentTests, _TestLibraryClassMixin):
+    comp = GratingComponent
+    libraryClass = GratingStim

psychopy/tests/test_experiment/test_components/test_ImageComponent.py

@@ -0,0 +1,8 @@
+from psychopy.experiment.components.image import ImageComponent
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestDepthMixin, _TestLibraryClassMixin
+from psychopy.visual.image import ImageStim
+
+
+class TestImage(BaseComponentTests, _TestLibraryClassMixin):
+    comp = ImageComponent
+    libraryClass = ImageStim

psychopy/tests/test_experiment/test_components/test_KeyboardComponent.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+from psychopy.experiment.components.keyboard import KeyboardComponent
+from psychopy.hardware.keyboard import Keyboard, KeyboardDevice
+from psychopy.tests import utils
+from psychopy.tests.test_experiment.test_components import BaseComponentTests
+from psychopy import session
+
+
+class TestKeyboardComponent(BaseComponentTests):
+    comp = KeyboardComponent
+    libraryClass = Keyboard
+
+    def setup_class(self):
+        # make a Session
+        self.session = session.Session(
+            root=Path(utils.TESTS_DATA_PATH) / "test_components",
+        )
+        # setup default window
+        self.session.setupWindowFromParams({})
+
+    def testKeyboardClear(self):
+        """
+        Test that KeyPress responses are cleared at the start of each Routine
+        """
+        # add keyboard clear experiment
+        self.session.addExperiment("testClearKeyboard/testClearKeyboard.psyexp", "keyboardClear")
+        # run keyboard clear experiment (will error if assertion not met)
+        self.session.runExperiment("keyboardClear")

psychopy/tests/test_experiment/test_components/test_MouseComponent.py

@@ -0,0 +1,136 @@
+from pathlib import Path
+
+from . import BaseComponentTests
+from psychopy.experiment.loops import TrialHandler
+from psychopy.experiment.components.mouse import MouseComponent
+from psychopy.experiment.components.polygon import PolygonComponent
+from psychopy.tests.utils import TESTS_DATA_PATH
+from psychopy.hardware.mouse import Mouse
+
+
+class TestMouseComponent(BaseComponentTests):
+    """
+    Test that Mouse coponents have the correct params and write as expected.
+    """
+    comp = MouseComponent
+    libraryClass = Mouse
+
+    def test_click_save_end_clickable_cases(self):
+        """
+        Test all combinations of options for what to save, what can be clicked on & what kind of clicks to end the
+        routine on.
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # make a rect for when we need something to click on
+        target = PolygonComponent(exp=exp, parentName=rt.name, name="testPolygon")
+        
+        saveMouseStateCases = [
+            {'val': "final",
+             'want': [f"thisExp.addData('{comp.name}.x', x)"],  # should contain code for adding final value of x
+             'avoid': [f"{comp.name}.x.append(float(x))"]},  # should not contain code to update testMouse.x in frame loop
+            {'val': "on click",
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(float(x))"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
+            {'val': "on valid click",
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(float(x))",  # should contain code to update testMouse.x in frame loop
+                      "if gotValidClick:"],  # should check for valid clicks
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
+            {'val': "every frame",
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(float(x))"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
+            {'val': "never",
+             'want': [],
+             'avoid': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should not add testMouse.x at the end
+                       f"{comp.name}.x.append(float(x))",  # should not contain code to update testMouse.x in frame loop
+                       f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x]},
+        ]
+        forceEndRoutineOnPressCases = [
+            {'val':  "never",
+             'want': [],
+             'avoid': ["# end routine on response",  # should not include code to end routine
+                       "# end routine on response"]},
+            {'val': "any click",
+             'want': ["# end routine on response"],  # should include code to end routine on response
+             'avoid': []},
+            {'val': "valid click",
+             'want': ["# end routine on response",  # should include code to end routine on response
+                      "if gotValidClick:"],  # should check for valid clicks
+             'avoid': []},
+        ]
+        clickableCases = [
+            {'val': "[]",
+             'want': [],
+             'avoid': ["clickableList = [testPolygon]"]},  # should not define a populated clickables list
+            {'val': "[testPolygon]",
+             'want': [],
+             'avoid': ["clickableList = []"]},  # should not define a blank clickables list
+        ]
+        # Iterate through saveMouseState cases
+        for SMScase in saveMouseStateCases:
+            # Set saveMouseState
+            comp.params['saveMouseState'].val = SMScase['val']
+            for FEROPcase in forceEndRoutineOnPressCases:
+                # Set forceEndRoutineOnPress
+                comp.params['forceEndRoutineOnPress'].val = FEROPcase['val']
+                for Ccase in clickableCases:
+                    # Set clickable
+                    comp.params['clickable'].val = Ccase['val']
+
+                    # Compile script
+                    script = exp.writeScript(target="PsychoPy")
+                    try:
+                        # Look for wanted phrases
+                        for phrase in SMScase['want']:
+                            assert phrase in script, (
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                        for phrase in FEROPcase['want']:
+                            assert phrase in script, (
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                        for phrase in Ccase['want']:
+                            assert phrase in script, (
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                        # Check there's no avoid phrases
+                        for phrase in SMScase['avoid']:
+                            assert phrase not in script, (
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                        for phrase in FEROPcase['avoid']:
+                            assert phrase not in script, (
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                        for phrase in Ccase['avoid']:
+                            assert phrase not in script, (
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
+                            )
+                    except AssertionError as err:
+                        # If any assertion fails, save script to view
+                        filename = Path(TESTS_DATA_PATH) / f"{__class__.__name__}_clicks_cases_local.py"
+                        with open(filename, "w") as f:
+                            f.write(script)
+                        # Append ref to saved script in error message
+                        print(
+                            f"\n"
+                            f"Case: {SMScase} {FEROPcase} {Ccase}\n"
+                            f"Script saved at: {filename}\n"
+                        )
+                        # Raise original error
+                        raise err

psychopy/tests/test_experiment/test_components/test_PolygonComponent.py

@@ -0,0 +1,65 @@
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestLibraryClassMixin
+from psychopy.experiment.components.polygon import PolygonComponent
+from psychopy.visual.polygon import Polygon
+
+
+class TestPolygonComponent(BaseComponentTests, _TestLibraryClassMixin):
+    """
+    Test that Polygon coponents have the correct params and write as expected.
+    """
+    comp = PolygonComponent
+    libraryClass = Polygon
+
+    def test_vertices_usage(self):
+        """
+        Test that vertices values are used only under the correct conditions
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # Define values to look for and avoid in code according to value of shape
+        cases = [
+            # Shape is a line
+            {'val': "line",
+             'seek': ["visual.Line("],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "triangle",
+             'seek': ["visual.ShapeStim("],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "rectangle",
+             'seek': ["visual.Rect("],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "circle",
+             'seek': ["visual.ShapeStim(", "vertices='circle'"],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "cross",
+             'seek': ["visual.ShapeStim(", "vertices='cross'"],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "star",
+             'seek': ["visual.ShapeStim(", "vertices='star7'"],
+             'avoid': ["___nVertices___", "___vertices___"]},
+            {'val': "regular polygon...",
+             'seek': ["___nVertices___", "visual.Polygon("],
+             'avoid': ["___vertices___"]},
+            {'val': "custom polygon...",
+             'seek': ["___vertices___", "visual.ShapeStim("],
+             'avoid': ["___nVertices___"]},
+        ]
+        # Setup component with markers for nVertices and vertices
+        comp.params['nVertices'].val = "___nVertices___"
+        comp.params['vertices'].val = "___vertices___"
+        # Test each case
+        for case in cases:
+            # Set shape
+            comp.params['shape'].val = case['val']
+            # Write experiment
+            pyScript = exp.writeScript(target="PsychoPy")
+            # Look for sought values in experiment script
+            for seekVal in case['seek']:
+                assert seekVal in pyScript, (
+                    f"Could not find wanted value `{seekVal}` in experiment when polygon shape was {case['val']}."
+                )
+            # Look for avoid values in experiment script
+            for avoidVal in case['avoid']:
+                assert avoidVal not in pyScript, (
+                    f"Found unwanted value `{avoidVal}` in experiment when polygon shape was {case['val']}."
+                )

psychopy/tests/test_experiment/test_components/test_ResourceManagerComponent.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _find_global_resource_in_js_experiment
+from psychopy.experiment.components.resourceManager import ResourceManagerComponent
+from psychopy import experiment
+from ...utils import TESTS_DATA_PATH
+
+
+class TestResourceManagerComponent(BaseComponentTests):
+    comp = ResourceManagerComponent
+
+    def test_handled_resources_removed(self):
+        """
+        Check that resources handled by a resource manager are removed from the start of the experiment
+        """
+        cases = [
+            # Resource handled by resource manager component, no loop present
+            {'exp': "handledbyrm_noloop",
+             'seek': [],
+             'avoid': ['blue.png', 'white.png', 'yellow.png', 'groups.csv', 'groupA.csv', 'groupB.csv']},
+            # Resource handled by resource manager component, loop defined by constructed string
+            {'exp': "handledbyrm_strloop",
+             'seek': ['groupA.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png', 'groupB.csv', 'groups.csv']},
+            # Resource handled by resource manager component, loop defined by constructed string
+            {'exp': "handledbyrm_constrloop",
+             'seek': ['groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png']},
+            # Resource handled by resource manager component, loop defined by constructed string from loop
+            {'exp': "handledbyrm_recurloop",
+             'seek': ['groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png']},
+        ]
+
+        exp = experiment.Experiment()
+        for case in cases:
+            # Load experiment
+            exp.loadFromXML(Path(TESTS_DATA_PATH) / "test_get_resources" / (case['exp'] + ".psyexp"))
+            # Write to JS
+            script = exp.writeScript(target="PsychoJS")
+            # Check that all "seek" phrases are included
+            for phrase in case['seek']:
+                assert _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was not found in resources for {case['exp']}.psyexp"
+                )
+            # Check that all "avoid" phrases are excluded
+            for phrase in case['avoid']:
+                assert not _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was found in resources for {case['exp']}.psyexp"
+                )

psychopy/tests/test_experiment/test_components/test_RoutineSettingsComponent.py

@@ -0,0 +1,16 @@
+import pytest
+from pathlib import Path
+
+from psychopy.experiment.components.routineSettings import RoutineSettingsComponent
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests
+from psychopy.tests import utils
+
+
+class TestRoutineSettingsComponent(BaseComponentTests):
+    comp = RoutineSettingsComponent
+    
+    def test_disabled_code_muting(self):
+        """
+        RoutineSettings doesn't work like a normal Component w/r/t disabling, so skip this test
+        """
+        pytest.skip()

psychopy/tests/test_experiment/test_components/test_SettingsComponent.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+
+from .test_base_components import _find_global_resource_in_js_experiment
+from psychopy import experiment
+from ...utils import TESTS_DATA_PATH
+
+
+class TestSettingsComponent:
+    def test_unhandled_resources_js(self):
+        """
+        Check that resources not otherwise handled are present at the start of the experiment
+        """
+        cases = [
+            # Resource not handled, no loop present
+            {'exp': "unhandled_noloop",
+             'seek': ['blue.png'],
+             'avoid': ['white.png', 'yellow.png', 'groups.csv', 'groupA.csv', 'groupB.csv']},
+            # Resource not handled, loop defined by string
+            {'exp': "unhandled_strloop",
+             'seek': ['blue.png', 'white.png', 'groupA.csv'],
+             'avoid': ['yellow.png', 'groupB.csv', 'groups.csv']},
+            # Resource not handled, loop defined by constructed string
+            {'exp': "unhandled_constrloop",
+             'seek': ['blue.png', 'white.png', 'yellow.png', 'groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': []},
+            # Resource not handled, loop defined by constructed string from loop
+            {'exp': "unhandled_recurloop",
+             'seek': ['blue.png', 'white.png', 'yellow.png', 'groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': []},
+        ]
+
+        exp = experiment.Experiment()
+        for case in cases:
+            # Load experiment
+            exp.loadFromXML(Path(TESTS_DATA_PATH) / "test_get_resources" / (case['exp'] + ".psyexp"))
+            # Write to JS
+            script = exp.writeScript(target="PsychoJS")
+            # Check that all "seek" phrases are included
+            for phrase in case['seek']:
+                assert _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was not found in resources for {case['exp']}.psyexp"
+                )
+            # Check that all "avoid" phrases are excluded
+            for phrase in case['avoid']:
+                assert not _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was found in resources for {case['exp']}.psyexp"
+                )
+
+    def test_get_info(self):
+        # List of values for expInfo fields, with expected compiled values for python and js
+        cases = [
+            # Function call with multiple inputs
+            {'val': 'randint(0, 999)',
+             'py': "randint(0, 999)",
+             'js': "util.randint(0, 999)"}
+        ]
+
+        # Construct exp with one big expInfo string from cases
+        exp = experiment.Experiment()
+        exp.settings.params['Experiment info'].val = "{"
+        i = 0
+        for case in cases:
+            exp.settings.params['Experiment info'].val += f"'{i}': '{case['val']}',"
+            i += 1
+        exp.settings.params['Experiment info'].val += "}"
+
+        # Compile to py
+        pyScript = exp.writeScript(target="PsychoPy")
+        # Check py
+        expInfoStr = pyScript.split("expInfo = {")[1]
+        expInfoStr = expInfoStr.split("}")[0]
+        i = 0
+        for case in cases:
+            wanted = f"'{i}': {case['py']},"
+            assert wanted in expInfoStr, (
+                f"Could not find `{wanted}` in ```\n"
+                f"{expInfoStr}\n"
+                f"```"
+            )
+            i += 1

psychopy/tests/test_experiment/test_components/test_StaticComponent.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+from . import BaseComponentTests
+from .test_base_components import _find_global_resource_in_js_experiment
+from psychopy.experiment.components.static import StaticComponent
+from psychopy import experiment, data
+from ...utils import TESTS_DATA_PATH
+
+
+class TestStaticComponent(BaseComponentTests):
+    comp = StaticComponent
+
+    def test_handled_resources_removed(self):
+        """
+        Check that resources handled by a static component are removed from the start of the experiment
+        """
+        cases = [
+            # Resource handled by static component, no loop present
+            {'exp': "handledbystatic_noloop",
+             'seek': [],
+             'avoid': ['blue.png', 'white.png', 'yellow.png', 'groups.csv', 'groupA.csv', 'groupB.csv']},
+            # Resource handled by static component, loop defined by string
+            {'exp': "handledbystatic_strloop",
+             'seek': ['groupA.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png', 'groupB.csv', 'groups.csv']},
+            # Resource handled by static component, loop defined by constructed string
+            {'exp': "handledbystatic_constrloop",
+             'seek': ['groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png']},
+            # Resource handled by static component, loop defined by constructed string from loop
+            {'exp': "handledbystatic_recurloop",
+             'seek': ['groupA.csv', 'groupB.csv', 'groups.csv'],
+             'avoid': ['blue.png', 'white.png', 'yellow.png']},
+        ]
+
+        exp = experiment.Experiment()
+        for case in cases:
+            # Load experiment
+            exp.loadFromXML(Path(TESTS_DATA_PATH) / "test_get_resources" / (case['exp'] + ".psyexp"))
+            # Write to JS
+            script = exp.writeScript(target="PsychoJS")
+            # Check that all "seek" phrases are included
+            for phrase in case['seek']:
+                assert _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was not found in resources for {case['exp']}.psyexp"
+                )
+            # Check that all "avoid" phrases are excluded
+            for phrase in case['avoid']:
+                assert not _find_global_resource_in_js_experiment(script, phrase), (
+                    f"'{phrase}' was found in resources for {case['exp']}.psyexp"
+                )

psychopy/tests/test_experiment/test_components/test_UnknownPluginComponent.py

@@ -0,0 +1,27 @@
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests
+from psychopy.experiment.components.unknownPlugin import UnknownPluginComponent
+from psychopy.experiment import Experiment
+from psychopy.tests import utils
+from pathlib import Path
+
+class TestUnknownPluginComponent(BaseComponentTests):
+    comp = UnknownPluginComponent
+    
+    def test_load_resave(self):
+        """
+        Test that loading an experiment with an unrecognised plugin Component retains the original 
+        name and source plugin for that Component.
+        """
+        # load experiment from file which has an unrecognised plugin component in
+        testExp = Path(utils.TESTS_DATA_PATH) / "TestUnknownPluginComponent_load_resave.psyexp"
+        exp = Experiment.fromFile(testExp)
+        # get unrecognised component
+        comp = exp.routines['trial'][-1]
+        # check its type and plugin values
+        assert comp.type == "TestFromPluginComponent"
+        assert comp.plugin == "psychopy-plugin-which-doesnt-exist"
+        # get its xml
+        xml = comp._xml
+        # check its tag and plugin attribute are retained
+        assert xml.tag == "TestFromPluginComponent"
+        assert comp.plugin == "psychopy-plugin-which-doesnt-exist"

psychopy/tests/test_experiment/test_components/test_all_components.py

@@ -0,0 +1,104 @@
+from psychopy.experiment.exports import IndentingBuffer
+from . import BaseComponentTests
+from psychopy import experiment
+import inspect
+
+
+class _Generic(BaseComponentTests):
+    def __init__(self, compClass):
+        self.exp = experiment.Experiment()
+        self.rt = experiment.routines.Routine(exp=self.exp, name="testRoutine")
+        self.exp.addRoutine("testRoutine", self.rt)
+        self.exp.flow.addRoutine(self.rt, 0)
+        self.comp = compClass(exp=self.exp, parentName="testRoutine", name=f"test{compClass.__name__}")
+        self.rt.addComponent(self.comp)
+
+
+def test_all_components():
+    for compName, compClass in experiment.getAllComponents().items():
+        if compName == "SettingsComponent":
+            continue
+        # make a generic testing object for this component
+        tester = BaseComponentTests()
+        # make sure it has a comp class assigned
+        tester.comp = compClass
+        # Run each method from BaseComponentTests on tester
+        for attr, meth in BaseComponentTests.__dict__.items():
+            if inspect.ismethod(meth):
+                meth(tester)
+
+def test_all_have_depth():
+    # Define components which shouldn't have depth
+    exceptions = ("PanoramaComponent", "FaceAPIComponent")
+    # Create experiment
+    exp = experiment.Experiment()
+    rt = experiment.routines.Routine(exp=exp, name="testRoutine")
+    exp.addRoutine("testRoutine", rt)
+    exp.flow.addRoutine(rt, 0)
+    # Add one of each component to the routine
+    for compName, compClass in experiment.getAllComponents().items():
+        # Settings components don't count so don't include one at all
+        if compName in ("SettingsComponent",):
+            continue
+        comp = compClass(exp=exp, parentName="testRoutine", name=f"test{compClass.__name__}")
+        rt.addComponent(comp)
+    # For each component...
+    for comp in rt:
+        compName = type(comp).__name__
+        # This won't be relevant for non-visual stimuli
+        if compName in exceptions or not isinstance(comp, experiment.components.BaseVisualComponent):
+            continue
+        for target in ("PsychoPy", "PsychoJS"):
+            # Skip if target isn't applicable
+            if target not in comp.targets:
+                continue
+            # Crate buffer to get component code
+            buff = IndentingBuffer(target=target)
+            # Write init code
+            if target == "PsychoJS":
+                comp.writeInitCodeJS(buff)
+                sought = "depth:"
+            else:
+                comp.writeInitCode(buff)
+                sought = "depth="
+            script = buff.getvalue()
+            # Unless excepted, check that depth is in the output
+            assert sought in script.replace(" ", ""), (
+                f"Could not find any reference to depth in {target} init code for {compName}:\n"
+                f"{script}\n"
+                f"Any component drawn to the screen should be given a `depth` on init. If this component is a special "
+                f"case, you can mark it as exempt by adding it to the `exceptions` variable in this test.\n"
+            )
+
+
+def test_visual_set_autodraw():
+    """
+    Check that any components derived from BaseVisualComponent make some reference to `.autoDraw` in their each
+    frame code
+    """
+    # List of components to skip
+    skipComponents = ["ApertureComponent"]
+
+    for compName, compClass in experiment.getAllComponents().items():
+        # Skip component if marked to skip
+        if compName in skipComponents:
+            continue
+        # Skip if component isn't derived from BaseVisual
+        if not issubclass(compClass, experiment.components.BaseVisualComponent):
+            continue
+        # Make a generic testing object for this component
+        tester = _Generic(compClass).comp
+        if 'startVal' in tester.params:
+            tester.params['startVal'].val = 0
+        if 'stopVal' in tester.params:
+            tester.params['stopVal'].val = 1
+        # Create text buffer to write to
+        buff = IndentingBuffer(target="PsychoPy")
+        # Write each frame code
+        tester.writeFrameCode(buff)
+        code = buff.getvalue()
+        # Look for autoDraw refs
+        assert ".autoDraw = " in code or ".setAutoDraw(" in code, (
+            f"{compName} does not set autoDraw in its Each Frame code. If this is acceptable, add the component name "
+            f"to `skipComponents`."
+        )