mpf 0.58.0.dev1__py3-none-any.whl → 0.58.0.dev3__py3-none-any.whl

mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.58.0.dev1'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.58.0.dev3'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
 __short_version__ = '0.58'

mpf/config_spec.yaml

@@ -622,7 +622,7 @@ fast:
     __type__: config
     net: single|subconfig(fast_net)|None
     exp: single|subconfig(fast_exp)|None
-    exp_int: single|subconfig(fast_exp)|None    
+    exp_int: single|subconfig(fast_exp)|None
     aud: single|subconfig(fast_aud)|None
     seg: single|subconfig(fast_seg)|None
     dmd: single|subconfig(fast_dmd)|None
@@ -944,7 +944,7 @@ neoseg_displays:
     number_template: single|str|None
     start_x: single|float|None
     start_y: single|float|None
-    size: single|enum(2digit,8digit)|8digit
+    size: single|enum(2digit,8digit,2digit-rg-swapped,8digit-rg-swapped)|8digit
     light_template: single|subconfig(lights,device)|
 lights:
     __valid_in__: machine
@@ -1573,7 +1573,7 @@ settings:
     label: single|str|
     sort: single|int|
     values: dict|str:str|
-    key_type: single|enum(str,float,int)|str
+    key_type: single|enum(str,float,int,bool)|str
     default: single|str|
     machine_var: single|str|None
     settingType: single|str|standard

mpf/core/device_manager.py

@@ -172,7 +172,20 @@ class DeviceManager(MpfController):
             for device_name in config:
                 futures.append(collection[device_name].device_added_system_wide())
 
-        await asyncio.wait([asyncio.create_task(futures) for futures in futures])
+        fs = [asyncio.create_task(future) for future in futures]
+        done, pending = await asyncio.wait(fs, return_when=asyncio.FIRST_EXCEPTION)
+
+        # Check if any of the futures returned an exception and throw it
+        for task in done:
+            if task.cancelled():
+                continue
+
+            exc = task.exception()
+            if exc is not None:
+                for pending_task in pending:
+                    pending_task.cancel()
+                await asyncio.gather(*pending, return_exceptions=True)
+                raise exc
 
     # pylint: disable-msg=too-many-nested-blocks
     def get_device_control_events(self, config) -> Generator[Tuple[str, Callable, int, "Device"], None, None]:

mpf/core/events.py

@@ -224,14 +224,15 @@ class EventManager(MpfController):
                                      'handler you passed?'.format(handler, event))
 
             sig = inspect.signature(handler)
-            if 'kwargs' not in sig.parameters:
-                raise AssertionError("Handler {} for event '{}' is missing **kwargs. Actual signature: {}".format(
-                    handler, event, sig))
-
-            if sig.parameters['kwargs'].kind != inspect.Parameter.VAR_KEYWORD:
-                raise AssertionError("Handler {} for event '{}' param kwargs is missing '**'. "
+            catchall_name = next((name for name in ('kwargs', '_kwargs') if name in sig.parameters), None)
+            if catchall_name is None:
+                raise AssertionError("Handler {} for event '{}' is missing **kwargs. "
                                      "Actual signature: {}".format(handler, event, sig))
 
+            if sig.parameters[catchall_name].kind != inspect.Parameter.VAR_KEYWORD:
+                raise AssertionError("Handler {} for event '{}' param {} is missing '**'. "
+                                     "Actual signature: {}".format(handler, event, catchall_name, sig))
+
         event, condition, additional_priority = self.get_event_and_condition_from_string(event)
         priority += additional_priority
 
@@ -457,6 +458,8 @@ class EventManager(MpfController):
                                                              _future=future,
                                                              _keys=keys,
                                                              event=event_name)))
+
+        future.add_done_callback(lambda f: [self.remove_handler_by_key(k) for k in keys])
         return future
 
     def _wait_handler(self, _future: asyncio.Future, _keys: List[EventHandlerKey], **kwargs):

mpf/core/placeholder_manager.py

@@ -4,7 +4,7 @@ import string
 import asyncio
 import operator as op
 import abc
-from functools import lru_cache
+from functools import lru_cache, partial
 
 import re
 from typing import Tuple, List, Any, Union
@@ -860,8 +860,28 @@ class BasePlaceholderManager(MpfController):
             subscriptions.append(self.machine.wait_for_stop())
             future = Util.any(subscriptions)
         future = asyncio.ensure_future(future)
+
+        future.add_done_callback(
+            partial(self._cleanup_placeholder_subscriptions, subscriptions=subscriptions)
+        )
         return value, future
 
+    def _cleanup_placeholder_subscriptions(self, future, subscriptions):
+        """Cancel child placeholder subscriptions when the parent template frame finishes."""
+        del future
+
+        for sub in subscriptions:
+            if isinstance(sub, asyncio.Future):
+                if not sub.done():
+                    # Cancel outstanding asyncio Future/Task instance
+                    sub.cancel()
+            elif asyncio.iscoroutine(sub):
+                try:
+                    # close raw coroutines (like sleep)
+                    sub.close()
+                except RuntimeWarning:
+                    pass
+
     @lru_cache(typed=True)
     def parse_conditional_template(self, template, default_number=None):
         """Parse a template for condition and number and return a dict."""

mpf/core/utility_functions.py

@@ -57,6 +57,8 @@ class Util:
             return float(value)
         if type_name == "str":
             return str(value)
+        if type_name == "bool":
+            return str(value).lower() in ['true', 't', 'yes', 'enable', 'on', '1']
 
         raise AssertionError("Unknown type {}".format(type_name))
 
@@ -586,13 +588,16 @@ class Util:
         if isinstance(time_string, (int, float)):
             return int(time_string)
 
-        time_string = str(time_string).upper()
+        time_string = str(time_string).upper().strip()
 
-        if time_string.endswith('MS') or time_string.endswith('MSEC'):
-            return int(time_string[:-2])
+        if time_string == 'NONE':
+            return 0
+
+        if time_string.endswith('MS'):
+            return int(float(time_string[:-2]))
 
         if time_string.endswith('MSEC'):
-            return int(time_string[:-4])
+            return int(float(time_string[:-4]))
 
         if time_string.endswith('D'):
             return int(float(time_string[:-1]) * 86400 * 1000)
@@ -609,7 +614,7 @@ class Util:
         if time_string.endswith('SEC'):
             return int(float(time_string[:-3]) * 1000)
 
-        return int(time_string)
+        return int(float(time_string))
 
     @staticmethod
     def string_to_secs(time_string: str) -> float:
@@ -847,4 +852,4 @@ class Util:
             bool: True if the bit is set, False otherwise
         """
         num = int(hex_string, 16)
-        return bool(num & (1 << bit))
+        return bool(num & (1 << bit))

mpf/devices/light_group.py

@@ -14,6 +14,21 @@ from mpf.core.system_wide_device import SystemWideDevice
 from mpf.devices.light import Light
 
 
+NEOSEG_8DIGIT_ORDER = [
+    95, 90, 93, 82, 85, 89, 86, 91, 88, 87, 81, 92, 83, 84, 94,
+    104, 76, 79, 96, 99, 103, 100, 77, 102, 101, 75, 78, 97, 98, 80,
+    110, 105, 108, 67, 70, 74, 71, 106, 73, 72, 66, 107, 68, 69, 109,
+    119, 61, 64, 111, 114, 118, 115, 62, 117, 116, 60, 63, 112, 113, 65,
+    5, 0, 3, 52, 55, 59, 56, 1, 58, 57, 51, 2, 53, 54, 4,
+    14, 46, 49, 6, 9, 13, 10, 47, 12, 11, 45, 48, 7, 8, 50,
+    20, 15, 18, 37, 40, 44, 41, 16, 43, 42, 36, 17, 38, 39, 19,
+    29, 31, 34, 21, 24, 28, 25, 32, 27, 26, 30, 33, 22, 23, 35]
+
+NEOSEG_2DIGIT_ORDER = [
+    5, 0, 3, 22, 25, 29, 26, 1, 28, 27, 21, 2, 23, 24, 4,
+    14, 16, 19, 6, 9, 13, 10, 17, 12, 11, 15, 18, 7, 8, 20]
+
+
 class LightGroup(SystemWideDevice):
 
     """An abstract group of lights."""
@@ -92,25 +107,41 @@ class LightGroup(SystemWideDevice):
         for light in self.lights:
             light.color(color, fade_ms, priority, key)
 
+    def _swap_grb_rgb_channel_offsets(self, offsets):
+        """Swap every first and second out of sets of three (GRB->RGB)."""
+        adjustments = {0: 1, 1: -1, 2: 0}
+        return [
+            x + adjustments[x % 3]
+            for x in offsets
+        ]
+
     def _reorder_lights(self):
         if self.config['size'] == '8digit':
             #Magic order for 8 digit NeoSeg displays from CobraPin
-            order = [95, 90, 93, 82, 85, 89, 86, 91, 88, 87, 81, 92, 83, 84, 94,
-                     104, 76, 79, 96, 99, 103, 100, 77, 102, 101, 75, 78, 97, 98, 80,
-                     110, 105, 108, 67, 70, 74, 71, 106, 73, 72, 66, 107, 68, 69, 109,
-                     119, 61, 64, 111, 114, 118, 115, 62, 117, 116, 60, 63, 112, 113, 65,
-                     5, 0, 3, 52, 55, 59, 56, 1, 58, 57, 51, 2, 53, 54, 4,
-                     14, 46, 49, 6, 9, 13, 10, 47, 12, 11, 45, 48, 7, 8, 50,
-                     20, 15, 18, 37, 40, 44, 41, 16, 43, 42, 36, 17, 38, 39, 19,
-                     29, 31, 34, 21, 24, 28, 25, 32, 27, 26, 30, 33, 22, 23, 35]
+            order = NEOSEG_8DIGIT_ORDER
+
         elif self.config['size'] == '2digit':
             #Magic order for 2 digit NeoSeg displays from CobraPin
-            order = [5, 0, 3, 22, 25, 29, 26, 1, 28, 27, 21, 2, 23, 24, 4,
-                     14, 16, 19, 6, 9, 13, 10, 17, 12, 11, 15, 18, 7, 8, 20]
+            order = NEOSEG_2DIGIT_ORDER
+
+        elif self.config['size'] == '8digit-rg-swapped':
+            #Magic order for 8 digit NeoSeg displays from CobraPin when platform numbering uses RGB channel order
+            order = self._swap_grb_rgb_channel_offsets(NEOSEG_8DIGIT_ORDER)
+
+        elif self.config['size'] == '2digit-rg-swapped':
+            #Magic order for 2 digit NeoSeg displays from CobraPin when platform numbering uses RGB channel order
+            order = self._swap_grb_rgb_channel_offsets(NEOSEG_2DIGIT_ORDER)
         else:
             order = range(0, len(self.lights))
 
-        self.lights = [self.lights[i] for i in order]
+        mapped_lights = []
+        try:
+            for i in order:
+                mapped_lights.append(self.lights[i])
+            self.lights = mapped_lights
+        except IndexError:
+            self.error_log("Attempted to use light index %s but source list only had %s items", i, len(self.lights))
+            raise
 
     def wait_for_loaded(self):
         """Return future."""
@@ -180,11 +211,12 @@ class NeoSegDisplay(LightGroup):
     __slots__ = []  # type: List[str]
 
     def _create_lights(self):
-        if self.config['size'] == '8digit':
+        if self.config['size'] in ('8digit', '8digit-rg-swapped'):
             count = 120
-        elif self.config['size'] == '2digit':
+        elif self.config['size'] in ('2digit', '2digit-rg-swapped'):
             count = 30
         else:
+            self.warning_log("NeoSegDisplay %s could not determine number of lights to create.", self.name)
             count = 0
 
         for index in range(self.config['number_start'], self.config['number_start'] + count):

mpf/devices/magnet.py

@@ -9,7 +9,7 @@ from mpf.core.device_monitor import DeviceMonitor
 from mpf.core.system_wide_device import SystemWideDevice
 
 
-@DeviceMonitor(_active="active", _release_in_progress="release_in_progress", _enabled="enabled")
+@DeviceMonitor(_active="active", _release_in_progress="release_in_progress", enabled="enabled")
 class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     """Controls a playfield magnet in a pinball machine."""

mpf/modes/match/code/match.py

@@ -18,10 +18,11 @@ class Match(AsyncMode):
         """Initialize match mode."""
         super().__init__(*args, **kwargs)
         # add setting
-        self.machine.settings.add_setting(SettingEntry("match_percentage", "Match Percentage", 500,
-                                                       "match_percentage", 10,
-                                                       {0: "Never", 2: "2%", 5: "5%", 10: "10%", 15: "15%", 30: "30%",
-                                                        50: "50%"}, "standard"))
+        self.machine.settings.add_setting(
+            SettingEntry("match_percentage",
+                         "Match Percentage", 500, "match_percentage", 10,
+                         {0: "Never", 2: "2%", 5: "5%", 10: "10%", 15: "15%", 30: "30%", 50: "50%"},
+                         "standard"))
 
     def _get_match_numbers(self):
         """Calculate match numbers."""
@@ -66,7 +67,12 @@ class Match(AsyncMode):
         self.machine.variables.set_machine_var('match_number', winner_number)
 
         for i in range(0, self.machine.game.max_players):
-            event_args["match_number{}".format(i)] = match_numbers[i] if len(match_numbers) > i else ""
+            player_value = ""
+            if len(match_numbers) > i:
+                player_value = match_numbers[i]
+
+            event_args["match_number{}".format(i)] = player_value
+            event_args["match_number{}_won".format(i)] = player_value == winner_number
 
         if not winners:
             # no winner
@@ -80,7 +86,9 @@ class Match(AsyncMode):
               winners: Number of winners (always 0 here)
               match_number0: Match number for player 0
               match_number1: Match number for player 1
+              match_number1_won: True/False for if player 1 matched
               match_numberX: Match number for player X (up to max players)
+              match_numberX_won: T/F for if player X matched (up to max players)
             '''
         else:
             # we got a winner
@@ -94,6 +102,8 @@ class Match(AsyncMode):
               winners: Number of winners (always more than 0 here)
               match_number0: Match number for player 0
               match_number1: Match number for player 1
+              match_number1_won: True/False for if player 1 matched
               match_numberX: Match number for player X (up to max players)
+              match_numberX_won: T/F for if player X matched (up to max players)
             '''
         # that is it. credits mode should hook into the match_has_match event and award credits

mpf/parsers/event_reference_parser.py

@@ -31,15 +31,19 @@ class EventReferenceParser:
                 class_label = None
                 config_section = None
                 for statement in x.body:
-                    if isinstance(statement, ast.Assign) and len(statement.targets) == 1 and \
-                       isinstance(statement.targets[0], ast.Name) and isinstance(statement.value, ast.Str):
+                    if (isinstance(statement, ast.Assign)
+                            and len(statement.targets) == 1
+                            and isinstance(statement.targets[0], ast.Name)
+                            and isinstance(statement.value, ast.Constant)
+                            and isinstance(statement.value.value, str)):
                         if statement.targets[0].id == "class_label":
-                            class_label = str(statement.value.s)
+                            class_label = str(statement.value.value)
                         elif statement.targets[0].id == "config_section":
-                            config_section = [str(statement.value.s)]
+                            config_section = [str(statement.value.value)]
 
                 for y in ast.walk(x):
-                    if not (isinstance(y, ast.Str) and (y.s.strip().lower().startswith('event:'))):
+                    if not (isinstance(y, ast.Constant) and isinstance(y.value, str)
+                            and y.value.strip().lower().startswith('event:')):
                         continue
 
                     event_dict = self._parse_string(y)
@@ -60,7 +64,7 @@ class EventReferenceParser:
 
     def _parse_string(self, string):
         string = '\n'.join(' '.join(line.split())
-                           for line in string.s.split('\n'))
+                           for line in string.value.split('\n'))
 
         string = string.replace('Event:', 'event:')
         string = string.replace('Desc:', 'desc:')

mpf/platforms/fast/fast.py

@@ -593,10 +593,13 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
             return FASTMatrixLight(number, self.serial_connections['net'], self.machine,
                                    int(1 / self.config['net']['lamp_hz'] * 1000), self)
         if not subtype or subtype == "led":
-            # make everything lowercase and strip trailing channel number
-            parts, channel = number.lower().rsplit('-', 1)
-            # split into board name, breakout, port, led
-            parts = parts.split('-')
+            try:
+                # make everything lowercase and strip trailing channel number
+                parts, channel = number.lower().rsplit('-', 1)
+                # split into board name, breakout, port, led
+                parts = parts.split('-')
+            except ValueError as e:
+                raise ValueError(f"Unable to parse FAST light '{config.name}' address {number}") from e
 
             if parts[0] in self.exp_boards_by_name:  # this is an expansion board LED in config file format
                 return self._add_exp_led_with_config_format(parts, channel, config.name)

mpf/platforms/fast/fast_led.py

@@ -40,7 +40,11 @@ class FASTRGBLED:
             channel = self.channels[index]
             if channel:
                 brightness, _, done = channel.get_fade_and_brightness(current_time)
-                result += f'{int(brightness * 255):02X}'
+                # Clamp to a single byte: an out-of-range brightness here would
+                # format to a 1- or 3-char hex channel and crash the downstream
+                # binascii unpacking with an "Odd-length string" error.
+                clamped_brightness = min(255, max(0, int(brightness * 255)))
+                result += f'{clamped_brightness:02X}'
                 if not done:
                     self.dirty = True
             else:
@@ -116,6 +120,12 @@ class FASTLEDChannel(LightPlatformInterface):
             fade_ms = max_fade_ms
             ratio = ((current_time + (fade_ms / 1000.0) - start_time) /
                      (target_time - start_time))
+            # A fade's start_time and the current_time passed in come from
+            # separate clock reads, so current_time can land a hair before
+            # start_time, making this ratio slightly out of [0, 1]. That would
+            # push brightness below 0 (fade up) or above 1 (fade down); clamp
+            # the ratio so the interpolation stays in range for both directions.
+            ratio = max(0.0, min(1.0, ratio))
             brightness = start_brightness + (target_brightness - start_brightness) * ratio
             done = False
         else:
@@ -125,15 +135,15 @@ class FASTLEDChannel(LightPlatformInterface):
             self._last_brightness = brightness
             done = True
 
-        # There is a bug that can sometimes cause the start_time to be ahead of the current_time,
-        # resulting in a negative brightness value. This may be a floating-point rounding error,
-        # or maybe something else. I can't figure it out, so just floor the value to be non-negative.
-        if brightness < 0:
-            brightness = 0
-            self.led.log.warning("Calculated a negative brightness (%s) for led %s channel %s. current_time: %s "
+        # Final guard in case start/target brightness themselves are ever out
+        # of [0, 1]: an out-of-range value would crash the hex formatter in
+        # current_color, so clamp both ends.
+        if brightness < 0 or brightness > 1:
+            self.led.log.warning("Calculated an out-of-range brightness (%s) for led %s channel %s. current_time: %s "
                                  "start_brightness: %s, start_time: %s, target_brightness: %s, target_time: %s",
                                  brightness, self.led, self.channel, current_time, start_brightness, start_time,
                                  target_brightness, target_time)
+            brightness = max(0.0, min(1.0, brightness))
 
         return brightness, fade_ms, done
 

mpf/platforms/virtual_pinball/virtual_pinball.py

@@ -1,5 +1,6 @@
 """VPX platform."""
 import asyncio
+import inspect
 from typing import Dict, List, Optional
 
 import logging
@@ -159,7 +160,7 @@ class VirtualPinballPlatform(LightsPlatform, SwitchPlatform, DriverPlatform, Seg
 
     """VPX platform."""
 
-    __slots__ = ["_lights", "_switches", "_drivers", "_last_drivers", "_last_lights", 
+    __slots__ = ["_lights", "_switches", "_drivers", "_last_drivers", "_last_lights",
                  "_started", "rules", "_configured_segment_displays", "_last_segment_text"]
 
     def __init__(self, machine):
@@ -200,6 +201,8 @@ class VirtualPinballPlatform(LightsPlatform, SwitchPlatform, DriverPlatform, Seg
 
         try:
             result = method(**kwargs)
+            if inspect.iscoroutine(result):
+                result = await result
         # pylint: disable-msg=broad-except
         except Exception as e:
             self.machine.bcp.transport.send_to_client(client, "vpcom_bridge_response",
@@ -212,6 +215,24 @@ class VirtualPinballPlatform(LightsPlatform, SwitchPlatform, DriverPlatform, Seg
         self._started.set()
         return True
 
+    async def vpx_reset(self):
+        """Wipe platform-side switch mirror and reset the machine.
+
+        Called by the VPX plugin on every (re)connect to give VPX a clean
+        MPF to talk to. Mechanisms (servos, motors, drop targets, diverters)
+        auto-reset because they subscribe to machine_reset_phase_3.
+
+        Order matters: clear switches first so reset-phase handlers see the
+        cleaned state instead of stale readings from the prior VPX session.
+        """
+        for num, sw in list(self._switches.items()):
+            if sw.state:
+                sw.state = False
+                self.machine.switch_controller.process_switch_by_num(
+                    state=0, num=num, platform=self)
+        await self.machine.reset()
+        return True
+
     def vpx_get_switch(self, number):
         """Return switch value."""
         # pylint: disable-msg=no-else-return

mpf/tests/machine_files/auditor/config/config.yaml

@@ -6,7 +6,7 @@ game:
 player_vars:
     score:
         initial_value: 0
-    my_var: 
+    my_var:
         initial_value: 0
 
 auditor:

mpf/tests/machine_files/custom_code/code/test_code.py

@@ -6,7 +6,11 @@ class TestCustomCode(CustomCode):
         self.log.debug("Loaded!")
 
         self.machine.events.add_handler('test_event', self._update)
+        self.machine.events.add_handler('test_event_2', self._alternative_kwargs)
 
     def _update(self, **kwargs):
         del kwargs
         self.machine.events.post("test_response")
+
+    def _alternative_kwargs(self, **_kwargs):
+        self.machine.events.post("test_response_2")

mpf/tests/machine_files/event_manager/config/test_event_manager.yaml

@@ -7,6 +7,12 @@ event_player:
     test_event_player_delayed:
         - test_event_player2|2s
         - test_event_player3:2s
+    "{machine.lifetime_earnings >= 500}": never_happens_machine
+    "{machine.switches.s_test_1.state == 1}": sometimes_happens_switch
+
+switches:
+    s_test_1:
+        number:
 
 random_event_player:
     test_random_event_player1:

mpf/tests/machine_files/event_manager/modes/game_mode/config/game_mode.yaml

@@ -3,6 +3,11 @@ mode:
   start_events: game_mode_start
   stop_events: game_mode_end
 
+event_player:
+    "{players[0].score>=99999999}": never_happens_players
+    "{current_player.score>=999999999}": never_happens_player
+    "{current_player.score<=current_player.score + 1 and current_player.score > -1}": always_happens_multiple_ast
+
 random_event_player:
     test_random_event_player_mode2:
         - out1

mpf/tests/machine_files/light/config/light_groups.yaml

@@ -50,3 +50,15 @@ neoseg_displays:
     light_template:
       type: w
       subtype: led
+  neoSeg_2:
+    start_channel: 0-1-0
+    size: 8digit-rg-swapped
+    light_template:
+      type: w
+      subtype: led
+  neoSeg_3:
+    start_channel: 0-1-120
+    size: 2digit-rg-swapped
+    light_template:
+      type: w
+      subtype: led

mpf/tests/machine_files/settings/config/config.yaml

@@ -19,3 +19,30 @@ settings:
             zero: "Zero"
             one: "One"
             two: "Two"
+    custom_setting_float:
+        label: "Float Setting"
+        key_type: float
+        default: 0.1
+        sort: 3
+        values:
+            0: "Zero"
+            0.1: "Point One"
+            1.0: "One"
+            2.5: "Two Point Five"
+    custom_setting_bool_t:
+        label: "Boolean Setting Default True"
+        key_type: bool
+        default: true
+        sort: 4
+        values:
+            true: "yes"
+            false: "off"
+
+    custom_setting_bool_f:
+        label: "Boolean Setting Default False"
+        key_type: bool
+        default: false
+        sort: 5
+        values:
+            true: "on"
+            false: "no"

mpf/tests/test_CustomCode.py

@@ -15,3 +15,10 @@ class TestCustomCode(MpfTestCase):
         self.machine_run()
 
         self.assertEqual(1, self._events['test_response'])
+
+    def test_scoring_2(self):
+        self.mock_event("test_response_2")
+        self.post_event("test_event_2")
+        self.machine_run()
+
+        self.assertEqual(1, self._events['test_response_2'])