psychopy 2024.2.5__py3-none-any.whl → 2025.1.0__py3-none-any.whl

psychopy/tests/test_experiment/needs_wx/test_components.py

@@ -63,7 +63,7 @@ class TestComponents():
         pass
 
     def test_component_attribs(self):
-        with io.open(self.baselineProfile, 'r', encoding='utf-8-sig') as f:
+        with io.open(self.baselineProfile, 'r', encoding='utf-8-sig', errors='ignore') as f:
             target = f.read()
         targetLines = target.splitlines()
         targetTag = {}

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_all_components.py

@@ -29,7 +29,7 @@ def test_all_components():
 
 def test_all_have_depth():
     # Define components which shouldn't have depth
-    exceptions = ("PanoramaComponent",)
+    exceptions = ("PanoramaComponent", "FaceAPIComponent")
     # Create experiment
     exp = experiment.Experiment()
     rt = experiment.routines.Routine(exp=exp, name="testRoutine")

psychopy/tests/test_experiment/test_components/test_base_components.py

@@ -3,7 +3,9 @@ import esprima
 import re
 from pathlib import Path
 
+import esprima.error_handler
 import pytest
+import tempfile
 
 from psychopy import experiment
 from psychopy.experiment.loops import TrialHandler
@@ -27,7 +29,7 @@ def _find_global_resource_in_js_experiment(script, resource):
         return present
 
     # Extract resources def at start of experiment
-    resourcesStr = re.search("(?<=resources: \[)[^\]]*", script).group(0)
+    resourcesStr = re.search(r"(?<=resources: \[)[^\]]*", script).group(0)
     # Return bool for whether specified resource is present
     return resource in resourcesStr
 
@@ -43,6 +45,7 @@ class BaseComponentTests:
         """
         # make blank experiment
         exp = experiment.Experiment()
+        exp.name = "Test" + self.comp.__name__ + "MinimalExp"
         # add a Routine
         rt = exp.addRoutine(routineName='TestRoutine')
         exp.flow.addRoutine(rt, 0)
@@ -68,6 +71,16 @@ class BaseComponentTests:
     
     # --- Heritable tests ---
 
+    def test_syntax_errors(self):
+        """
+        Create a basic implementation of this Component with everything set to defaults and check 
+        whether the resulting code has syntax errors
+        """
+        # create minimal experiment
+        comp, rt, exp = self.make_minimal_experiment()
+        # check syntax
+        utils.checkSyntax(exp, targets=self.comp.targets)
+
     def test_icons(self):
         """
         Check that Component has icons for each app theme and that these point to real files
@@ -169,11 +182,11 @@ class BaseComponentTests:
         # define cases and expected start/dur
         cases = [
             # blank start
-            {'startVal': "", 'stopVal': "1", 'startTime': None, 'duration': 1},
+            {'name': "NoStart", 'startVal': "", 'stopVal': "1", 'startTime': None, 'duration': 1},
             # blank stop
-            {'startVal': "0", 'stopVal': "", 'startTime': 0, 'duration': FOREVER},
+            {'name': "NoStop", 'startVal': "0", 'stopVal': "", 'startTime': 0, 'duration': FOREVER},
             # blank both
-            {'startVal': "", 'stopVal': "", 'startTime': None, 'duration': FOREVER},
+            {'name': "NoStartStop", 'startVal': "", 'stopVal': "", 'startTime': None, 'duration': FOREVER},
         ]
         # run all cases
         for case in cases:
@@ -187,23 +200,19 @@ class BaseComponentTests:
             assert duration == case['duration']
             # check that it's never non-slip safe
             assert not nonSlipSafe
-            # temp file to save scripts to for flake
-            import tempfile
-            file = Path(tempfile.gettempdir()) / "test_blank_timing_script.py"
-            # write the script
-            script = exp.writeScript(target="PsychoPy")
-            file.write_text(script, encoding="utf-8")
-            # check for syntax errors
+            # update experiment name to indicate what case we're in
+            case['name'] = self.comp.__name__ + case['name']
+            exp.name = "Test%(name)sExp" % case
+            # check that it still writes syntactially valid code
             try:
-                compile(script, str(file), "exec")
-            except Exception as err:
-                # save script
-                case['fail'] = Path(utils.TESTS_FAILS_PATH) / "test_blank_timing_script.py"
-                case['fail'].write_text(script, encoding="utf-8")
+                utils.checkSyntax(exp, targets=self.comp.targets)
+            except SyntaxError as err:
                 # raise error
+                case['err'] = err
                 raise AssertionError(
                     "Syntax error in compiled Builder code when startVal was '%(startVal)s' and "
-                    "stopVal was '%(stopVal)s'. Failed script saved in '%(fail)s'" % case
+                    "stopVal was '%(stopVal)s'. Failed script saved in psychopy/tests/fails. "
+                    "Original error: %(err)s" % case
                 )
 
     def test_disabled_default_val(self):

psychopy/tests/test_experiment/test_loops.py

@@ -5,9 +5,10 @@ from pathlib import Path
 from tempfile import mkdtemp
 
 import numpy as np
+import pandas as pd
 
 from ..utils import TESTS_DATA_PATH
-from psychopy import experiment, core
+from psychopy import experiment, core, logging
 
 from psychopy import prefs, core
 prefs.hardware['audioLib'] = ['ptb', 'sounddevice']
@@ -54,13 +55,16 @@ class TestLoops:
 
             # Run Python script to generate data file
             stdout, stderr = core.shellCall([sys.executable, str(pyScriptFile)], stderr=True)
+            # print stdout so the test suite can see it
             print(stdout)
-            print(stderr)
+            # log any errors so the test suite can see them
+            if stderr:
+                logging.error(stderr)
+            # error if data didn't save
             if not datafile.is_file():
                 raise RuntimeError("Data file wasn't saved. PsychoPy StdErr below:\n" + stderr)
             # Load data file
-            with open(datafile, "rb") as f:
-                data = np.recfromcsv(f, case_sensitive=True)
+            data = pd.read_csv(str(datafile)).values.tolist()
 
             # Store
             cls.cases[filename] = {
@@ -71,6 +75,10 @@ class TestLoops:
                 'stdout': stdout,
                 'stderr': stderr,
             }
+    
+    def teardown_class(cls):
+        # delete temp folder
+        shutil.rmtree(cls.tempDir)
 
     def test_output_length(self):
         """

psychopy/tests/test_experiment/test_params.py

@@ -91,9 +91,9 @@ class TestStyle:
             phrase = re.sub(pattern=(
                 f"(?<= )({pattern})(?= )"  # space before and after
                 f"|(?<= )({pattern})$"  # space before and line end after
-                f"|(?<= )({pattern})(?=[^\w\s]+)"  # space before and punctuation after
+                f"|(?<= )({pattern})(?=[^\\w\\s]+)"  # space before and punctuation after
                 f"|^({pattern})(?= )"  # line start before and space after
-                f"|^({pattern})(?=[^\w\s]+)"  # line start before and punctuation after
+                f"|^({pattern})(?=[^\\w\\s]+)"  # line start before and punctuation after
                 f"|^({pattern})$"  # line start before and line end after
             ), string=phrase, repl=repl)
 
@@ -174,8 +174,8 @@ def test_param_str():
          "js": f"{_q}Hello there{_q}"},
         # Enforced string
         {"obj": Param("\\, | or /", "str", canBePath=False),
-         "py": f"{_q}{_sl}, \| or /{_q}",
-         "js": f"{_q}{_sl}, \| or /{_q}"},
+         "py": f"{_q}{_sl}, \\| or /{_q}",
+         "js": f"{_q}{_sl}, \\| or /{_q}"},
         # Dollar string
         {"obj": Param("$win.color", "str"),
          "py": f"win.color",
@@ -270,6 +270,19 @@ def test_param_str():
         {'obj': Param("$left", "list"),
          'py': r"left",
          'js': r"left"},
+        # f strings as code with a newline (GitHub issue #3476)
+        # (uncomment when JS resolves as described below)
+        # {'obj': Param("$f\"I would like a \\n line break here\"", "str"), 
+        #  'py': r"f\"I would like a \\n line break here\"",
+        #  'js': r"`I would like a \\n line break here`"},
+        # backslash in file path (GitHub issue #3734)
+        {'obj': Param("path\\to\\resource", "str", canBePath=True),
+         'py': r"'path/to/resource'",
+         'js': r"'path/to/resource'"},
+        # dollar sign in string (GitHub issue #4259)
+        {'obj': Param("$Math.E+'$'", "str"),
+         'py': r"Math\.E\+'\$'",
+         'js': r"\(Math.E \+ \"\$\"\)"},
     ]
 
     # Take note of what the script target started as

psychopy/tests/test_experiment/test_routines/test_PhotodiodeValidationRoutine.py

@@ -1,9 +1,9 @@
 from . import _TestDisabledMixin, _TestBaseStandaloneRoutinesMixin
 from psychopy import experiment
-from psychopy.experiment.routines.photodiodeValidator import PhotodiodeValidatorRoutine
+from psychopy.experiment.routines.visualValidator import VisualValidatorRoutine
 
 
 class TestEyetrackerCalibrationRoutine(_TestBaseStandaloneRoutinesMixin, _TestDisabledMixin):
     def setup_method(self):
         self.exp = experiment.Experiment()
-        self.rt = PhotodiodeValidatorRoutine(exp=self.exp, name="testPhotodiodeValidatorRoutine")
+        self.rt = VisualValidatorRoutine(exp=self.exp, name="testVisualValidatorRoutine")

psychopy/tests/test_hardware/test_photodiode.py

@@ -0,0 +1,66 @@
+import pytest
+from psychopy import core, visual
+from psychopy.tests.utils import RUNNING_IN_VM
+from psychopy.hardware.lightsensor import BaseLightSensorGroup, LightSensorResponse
+
+
+class DummyPhotodiode(BaseLightSensorGroup):
+
+    def __init__(self, channels=1, threshold=None, pos=None, size=None, units=None):
+        # make a basic timer
+        self.timer = core.Clock()
+        # queue of messages that can be manually added
+        self.queue = []
+        # initialise base
+        BaseLightSensorGroup.__init__(
+            self, channels=channels, threshold=threshold, pos=pos, size=size, units=units
+        )
+
+    def dispatchMessages(self):
+        for msg in self.queue:
+            self.responses = self.parseMessage(msg)
+
+    def parseMessage(self, message):
+        """
+
+        Parameters
+        ----------
+        message : tuple[float, bool, int, float]
+            Raw message, in the format:
+                - float: Timestamp
+                - bool: True/False lightsensor state
+                - int: Channel in question
+
+        Returns
+        -------
+        LightSensorResponse
+            Photodiode response
+        """
+        # split message
+        t, value, channel = message
+        # make obj
+        return LightSensorResponse(
+            t, value, channel, threshold=self.threshold[channel]
+        )
+    
+    def _setThreshold(self, threshold, channel):
+        self.threshold[channel] = threshold
+
+    def resetTimer(self, clock=None):
+        self.timer.reset()
+
+class TestPhotodiode:
+
+    def setup_class(self):
+        self.lightsensor = DummyPhotodiode()
+        self.win = visual.Window()
+
+    def test_handle_no_response(self):
+        """
+        If no response (as will be the case here), should try n times and then give up.
+        """
+        # this one takes a while and isn't all that helpful if you can't watch it, so skip under vm
+        if RUNNING_IN_VM:
+            pytest.skip()
+        # try to find the lightsensor, knowing full well it'll get nothing as this is a dummy
+        self.lightsensor.findSensor(win=self.win, retryLimit=2)

psychopy/tests/test_liaison/test_Liaison.py

@@ -191,10 +191,10 @@ class TestLiaison:
         Test that attribute strings (e.g. "session.win") are actualized by Liaison to be the
         object they represent.
         """
-        # add screen buffer photodiode
+        # add screen buffer lightsensor
         runInLiaison(
             self.server, self.protocol, "DeviceManager", "addDevice",
-            "psychopy.hardware.photodiode.ScreenBufferSampler", "screenBuffer",
+            "psychopy.hardware.lightsensor.ScreenBufferSampler", "screenBuffer",
             "session.win"
         )
         # get screen buffer photodidoe
@@ -238,7 +238,7 @@ class TestLiaison:
     def test_device_JSON(self):
         cases = {
             'testMic': "psychopy.hardware.microphone.MicrophoneDevice",
-            'testPhotodiode': "psychopy.hardware.photodiode.ScreenBufferSampler",
+            'testPhotodiode': "psychopy.hardware.lightsensor.ScreenBufferSampler",
             'testButtonBox': "psychopy.hardware.button.KeyboardButtonBox"
         }
         for deviceName, deviceClass in cases.items():
@@ -272,4 +272,4 @@ class TestLiaison:
         # make sure error looks correct in JSON format
         result = self.protocol.messages[-1]
         assert result['type'] == "hardware_error"
-        assert "psychopy.hardware.manager.ManagedDeviceError" in result['msg']
+        assert "psychopy.hardware.exceptions.ManagedDeviceError" in result['msg']

psychopy/tests/test_misc/test_clock.py

@@ -6,6 +6,7 @@ import numpy as np
 from psychopy.clock import wait, StaticPeriod, CountdownTimer
 from psychopy.visual import Window
 from psychopy.tools import systemtools
+from psychopy.tests import skip_under_vm
 
 
 def test_StaticPeriod_finish_on_time():
@@ -36,6 +37,7 @@ def test_StaticPeriod_recordFrameIntervals():
     win.close()
 
 
+@skip_under_vm
 def test_StaticPeriod_screenHz():
     """Test if screenHz parameter is respected, i.e., if after completion of the
     StaticPeriod, 1/screenHz seconds are still remaining, so the period will

psychopy/tests/test_misc/test_color.py

@@ -6,6 +6,7 @@ tests in a setting where you can view the output if you have photosensitive
 epilepsy.
 
 """
+from psychopy.alerts import addAlertHandler
 from psychopy.alerts._errorHandler import _BaseErrorHandler
 from psychopy.tests import utils
 from psychopy import visual, colors
@@ -44,6 +45,7 @@ class Test_Window:
     def setup_class(self):
         self.win = visual.Window([128,128], pos=[50,50], allowGUI=False, autoLog=False)
         self.error = _BaseErrorHandler()
+        addAlertHandler(self.error)
 
     @classmethod
     def teardown_class(self):

psychopy/tests/test_misc/test_event.py

@@ -95,6 +95,7 @@ class _baseTest():
         event._onPygletMouseRelease(0, 0, LEFT | MIDDLE | RIGHT, None, emulated=True)
         assert not any(event.mouseButtons)
 
+    @skip_under_vm
     def test_mouse_clock(self):
         x, y = 0, 0
         scroll_x, scroll_y = 1, 1

psychopy/tests/test_plugins/test_plugin_stubs.py

@@ -0,0 +1,125 @@
+from http.client import RemoteDisconnected
+import importlib
+import pytest
+import requests
+from psychopy import logging
+from psychopy.plugins import PluginStub
+
+
+def test_plugin_stub_docs():
+    """
+    Test that links (docsHome and docsRef) are combined correctly in the docstring of PluginStub
+    """
+    cases = [
+        # docsHome with no docsRef
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/",
+            } 
+        },
+        # docsHome included in docsRef
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "https://psychopy.org/test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+        # docsRef without /
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+        # docsHome with /
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org/",
+            'docsRef': "/test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+    ]
+
+    for case in cases:
+        # subclass PluginStub with the given values
+        class TestPluginStub(
+            PluginStub,
+            plugin=case['plugin'],
+            docsHome=case['docsHome'],
+            docsRef=case['docsRef'],
+        ):
+            pass
+        # check for the necessary strings in its docstr
+        assert case['plugin'] in TestPluginStub.__doc__
+        assert "<%(docsHome)s>" % case['ans'] in TestPluginStub.__doc__
+        assert "<%(docsLink)s>" % case['ans'] in TestPluginStub.__doc__
+
+
+def test_plugin_stub_links():
+    # import modules with PluginStubs in them
+    knownStubModules = [
+        "psychopy.microphone",
+        "psychopy.hardware.cedrus",
+        "psychopy.hardware.emulator",
+        "psychopy.hardware.gammasci",
+        "psychopy.hardware.minolta",
+        "psychopy.hardware.minolta",
+        "psychopy.hardware.pr",
+        "psychopy.hardware.crs.bits",
+        "psychopy.hardware.crs.optical",
+        "psychopy.hardware.crs.shaders",
+        "psychopy.visual.movie2",
+        "psychopy.visual.movie3",
+        "psychopy.visual.noise",
+        "psychopy.visual.patch",
+        "psychopy.visual.radial",
+        "psychopy.visual.ratingscale",
+        "psychopy.visual.secondorder",
+        "psychopy.hardware.brainproducts",
+        "psychopy.hardware.forp",
+        "psychopy.hardware.iolab",
+        "psychopy.hardware.labjacks",
+        "psychopy.hardware.qmix",
+        "psychopy.hardware.bbtk",
+        "psychopy.sound.backend_pyo",
+        "psychopy.sound.backend_sounddevice",
+        "psychopy.visual.backends.glfwbackend",
+    ]
+    for stubModule in knownStubModules:
+        importlib.import_module(stubModule)
+    # check for an internet connection in general
+    resp = requests.get("https://psychopy.org")
+    if not resp.ok:
+        pytest.skip()
+    # iterate through subclasses of PluginStub
+    for cls in PluginStub.__subclasses__():
+        # skip PluginStubs from the test suite
+        if cls.__module__.startswith("psychopy.tests"):
+            continue
+        # get pages from web
+        try:
+            docsHome = requests.get(cls.docsHome)
+            docsLink = requests.get(cls.docsLink)
+        except RemoteDisconnected:
+            # skip test if there's a connection error
+            pytest.skip()
+        # check that we got some content
+        assert docsHome.ok, (
+            f"No documentation found at {cls.docsHome} (PluginStub for {cls.__module__}:{cls.__name__})"
+        )
+        assert docsLink.ok, (
+            f"No documentation found at {cls.docsLink} (PluginStub for {cls.__module__}:{cls.__name__})"
+        )

psychopy/tests/test_sound/test_sound.py

@@ -1,6 +1,7 @@
 """Test PsychoPy sound.py using pygame backend; will fail if have already used pyo
 """
 
+from pathlib import Path
 from psychopy import prefs, core, plugins
 prefs.hardware['audioLib'] = ['ptb', 'sounddevice']
 
@@ -8,6 +9,7 @@ import pytest
 import shutil
 from tempfile import mkdtemp
 from psychopy import sound #, microphone
+from psychopy.hardware import DeviceManager, speaker
 
 import numpy
 
@@ -16,52 +18,121 @@ import numpy
 from psychopy.tests.utils import TESTS_PATH, TESTS_DATA_PATH
 
 @pytest.mark.needs_sound
-class TesSounds:
-    @classmethod
+class TestSounds:
     def setup_class(self):
         self.contextName='ptb'
         self.tmp = mkdtemp(prefix='psychopy-tests-sound')
+        # create just one instance for each speaker
+        self.speakers = {}
+        for profile in DeviceManager.getAvailableDevices(
+            "psychopy.hardware.speaker.SpeakerDevice"
+        ):
+            self.speakers[profile['index']] = speaker.SpeakerDevice(profile['index'])
+        # if there's no devices, skip everything
+        if not len(self.speakers):
+            pytest.skip()
 
-    @classmethod
     def teardown_class(self):
+        for i, spk in self.speakers.items():
+            spk.close()
+        # delete temp dir
         if hasattr(self, 'tmp'):
             shutil.rmtree(self.tmp, ignore_errors=True)
 
-    def test_init(self):
-        for note in ['A', 440, '440', [1,2,3,4], numpy.array([1,2,3,4])]:
-            sound.Sound(note, secs=.1)
-        with pytest.raises(ValueError):
-            sound.Sound('this is not a file name')
-        with pytest.raises(ValueError):
-            sound.Sound(-1)
-        with pytest.raises(ValueError):
-            sound.Sound(440, secs=-1)
-        with pytest.raises(ValueError):
-            sound.Sound(440, secs=0)
-        with pytest.raises(DeprecationWarning):
-            sound.setaudioLib('foo')
+    def test_playback(self):
+        """
+        Check that Sound can be initialised with a variety of values
+        """
+        # check values which should work
+        cases = [
+            # default stim
+            "default.mp3",
+            "default.wav",
+            # extant file
+            Path(TESTS_DATA_PATH) / "Electronic_Chime-KevanGC-495939803.wav",
+            # notes
+            "A",
+            440,
+            '440', 
+            [1,2,3,4], 
+            numpy.array([1,2,3,4]),
+        ]
+        # try on every speaker
+        for i, spk in self.speakers.items():
+            for case in cases:
+                snd = sound.Sound(
+                    value=case,
+                    secs=0.1,
+                    speaker=spk,
+                )
+                snd.play()
+                snd.stop()
+    
+    def test_error(self):
+        """
+        Check that various invalid values raise the correct error
+        """
+        # check values which should error
+        cases = [
+            {'val': "'this is not a file name'", 'secs': .1, 'err': ValueError},
+            {'val': "-1", 'secs': .1, 'err': ValueError},
+        ]
+        # try on every speaker
+        for i, spk in self.speakers.items():
+            for case in cases:
+                with pytest.raises(case['err']):
+                    snd = sound.Sound(
+                        value=case['val'],
+                        secs=0.1,
+                        speaker=spk,
+                    )
+    
+    def test_sample_rate_mismatch(self):
+        """
+        Check that Sound can handle a mismatch of sample rates between a file and a speaker
+        """
+        # specify some common sample rates
+        sampleRates = (
+            8000,
+            16000,
+            22050,
+            32000,
+            44100,
+            48000,
+            96000,
+            192000,
+        )
+        # iterate through speakers
+        for i, spk in self.speakers.items():
+            for sr in sampleRates:
+                # try to play sound on speaker
+                try:
+                    snd = sound.Sound(
+                        value=Path(TESTS_DATA_PATH) / "test_sounds" / f"default_{sr}.wav",
+                        speaker=spk,
+                        secs=-1,
+                    )
+                    snd.play()
+                except Exception as err:
+                    # include sample rate of sound and speaker in error message
+                    raise ValueError(
+                        f"Failed to play sound at sample rate {sr} on speaker {i} (sample rate "
+                        f"{spk.sampleRateHz}), original error: {err}"
+                    )
+                # doesn't need to *actually* play, just check that it doesn't error
+                snd.stop()
 
-        points = 100
-        snd = numpy.ones(points) / 20
-
-        #testFile = os.path.join(self.tmp, 'green_48000.wav')
-        #r, d = wavfile.read(testFile)
-        #assert r == 48000
-        #assert len(d) == 92160
-        #s = sound.Sound(testFile)
-
-    def test_play(self):
-        s = sound.Sound(secs=0.1)
-        s.play()
-        core.wait(s.getDuration()+.1)  # allows coverage of _onEOS
-        s.play(loops=1)
-        core.wait(s.getDuration()*2+.1)
-        s.play(loops=-1)
-        s.stop()
-
-    def test_methods(self):
-        s = sound.Sound(secs=0.1)
-        v = s.getVolume()
-        assert v == 1
-        assert s.setVolume(0.5) == 0.5
-        #assert s.setLoops(2) == 2
+    def test_volume(self):
+        """
+        Test that Sound can handle setting/getting its volume
+        """
+        # make a basic sound
+        s = sound.Sound(value="A", secs=0.1)
+        # set volume
+        s.setVolume(1)
+        # check it
+        assert s.getVolume() == 1
+        # set to a different value
+        s.setVolume(0.5)
+        # check it
+        assert s.getVolume() == 0.5