hdk-sdl/test/Event_test.cpp

#include <doctest/doctest.h>

#include <SDL3/SDL.h>

#include <hdk/sdl/event.hpp>

#include <vector>

TEST_CASE("Event helpers and routers are exercised") {
  SDL_Event event {};
  event.type = SDL_EVENT_KEY_DOWN;
  event.key.key = SDLK_A;
  event.key.windowID = 7;

  char buffer[256] {};
  CHECK(hdk::sdl::Event::GetDescription(&event, buffer, sizeof(buffer)) >= 0);
  CHECK_FALSE(hdk::sdl::Event::GetDescription(&event).empty());
  CHECK_FALSE(hdk::sdl::Event::GetDescription<64>(&event).empty());
  (void)hdk::sdl::Event::EventEnabled(SDL_EVENT_KEY_DOWN);
  hdk::sdl::Event::FlushEvent(SDL_EVENT_FIRST);
  hdk::sdl::Event::FlushEvents(SDL_EVENT_FIRST, SDL_EVENT_LAST);
  CHECK_FALSE(hdk::sdl::Event::Has(SDL_EVENT_KEY_DOWN));
  CHECK_FALSE(hdk::sdl::Event::Has(SDL_EVENT_FIRST, SDL_EVENT_LAST));
  CHECK_FALSE(static_cast<bool>(hdk::sdl::Event::GetWindowFromEvent(&event)));

  auto noopTapFilter = [](void*, SDL_Event*) -> bool { return true; };
  hdk::sdl::Event::AddWatch(noopTapFilter, nullptr);
  hdk::sdl::Event::FilterEvents(noopTapFilter, nullptr);
  SDL_EventFilter filter = nullptr;
  void* filterData = nullptr;
  CHECK((hdk::sdl::Event::GetFilter(&filter, &filterData) || !hdk::sdl::Event::GetFilter(&filter, &filterData)));
  hdk::sdl::Event::Pump();
  CHECK((hdk::sdl::Event::Poll(&event) || !hdk::sdl::Event::Poll(&event)));
  SDL_Event peepEvents[2] {};
  CHECK(hdk::sdl::Event::Peep(peepEvents, 2, SDL_PEEKEVENT, SDL_EVENT_FIRST, SDL_EVENT_LAST) >= -1);
  CHECK((hdk::sdl::Event::Push(&event) || !hdk::sdl::Event::Push(&event)));

  hdk::sdl::evt::EventConduit conduit;
  int triggerCount = 0;
  auto tap = conduit.Attach([&](SDL_Event* evt) {
    if (evt) {
      ++triggerCount;
    }
  });
  REQUIRE(tap.IsActive());
  conduit.Trigger(&event);
  CHECK(triggerCount == 1);
  CHECK(tap.Pause());
  CHECK(tap.IsPaused());
  conduit.Trigger(&event);
  CHECK(triggerCount == 1);
  CHECK(tap.Resume());
  conduit.Trigger(&event);
  CHECK(triggerCount == 2);
  CHECK(tap.Detach());
  CHECK_FALSE(tap.IsActive());

  hdk::grid::eps::TapScope scope;
  auto scopeTap = conduit.Attach([&](SDL_Event*) { ++triggerCount; });
  scope << std::move(scopeTap);
  scope.PauseAll();
  conduit.Trigger(&event);
  scope.ResumeAll();
  conduit.Trigger(&event);
  scope.DetachAll();

  hdk::sdl::evt::KeyEvents keyEvents;
  hdk::sdl::evt::KeysEvents keysEvents;
  hdk::sdl::evt::JoystickAxisEvents joystickAxis;
  hdk::sdl::evt::JoystickBallEvents joystickBall;
  hdk::sdl::evt::JoystickHatEvents joystickHat;
  hdk::sdl::evt::JoystickButtonEvents joystickButton;
  hdk::sdl::evt::JoystickButtonsEvents joystickButtons;
  hdk::sdl::evt::JoysticksEvents joysticks;
  hdk::sdl::evt::GamepadAxisEvents gamepadAxis;
  hdk::sdl::evt::GamepadButtonEvents gamepadButton;
  hdk::sdl::evt::GamepadButtonsEvents gamepadButtons;
  hdk::sdl::evt::GamepadTouchpadEvents touchpad;
  hdk::sdl::evt::GamepadsEvents gamepads;
  hdk::sdl::evt::FingerEvents finger;
  hdk::sdl::evt::DropEvents drop;
  hdk::sdl::evt::AudioDeviceEvents audio;
  hdk::sdl::evt::PenEvents pen;
  hdk::sdl::evt::CameraDeviceEvents camera;
  hdk::sdl::evt::RenderEvents render;
  hdk::sdl::evt::KeyboardEvents keyboard;
  hdk::sdl::evt::MouseButtonEvents mouseButton;
  hdk::sdl::evt::MouseButtonsEvents mouseButtons;
  hdk::sdl::evt::MouseEvents mouse;
  hdk::sdl::evt::MiceEvents mice;
  hdk::sdl::evt::TextEvents text;
  hdk::sdl::evt::WindowEvents windowEvents;
  hdk::sdl::evt::WindowsEvents windows;
  hdk::sdl::evt::DisplayEvents displays;
  hdk::sdl::evt::AllTypes allTypes;
  hdk::sdl::evt::KeyEvents keyedWindowEvents;

  auto windowTap = windows[7].Shown.Attach([&](SDL_Event*) { ++triggerCount; });
  allTypes.Window[7].Key.value_dispatch_map[SDLK_A] = &keyedWindowEvents;
  auto allTap = keyedWindowEvents.Down.Attach([&](SDL_Event*) { ++triggerCount; });
  CHECK(windowTap.IsActive());
  CHECK(allTap.IsActive());

  event.type = SDL_EVENT_WINDOW_SHOWN;
  event.window.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  windows.Trigger(&event);

  event.type = SDL_EVENT_KEY_DOWN;
  event.key.windowID = 7;
  event.key.key = SDLK_A;
  CHECK(keyEvents.extractor(&event) == SDL_EVENT_KEY_DOWN);
  CHECK(keysEvents.extractor(&event) == SDLK_A);
  allTypes.Trigger(&event);

  event.type = SDL_EVENT_MOUSE_BUTTON_DOWN;
  event.button.which = 11;
  event.button.button = SDL_BUTTON_LEFT;
  event.button.windowID = 7;
  CHECK(mouseButtons.extractor(&event) == SDL_BUTTON_LEFT);
  CHECK(mice.extractor(&event) == 11);
  mouse.Trigger(&event);

  event.type = SDL_EVENT_MOUSE_WHEEL;
  event.wheel.which = 12;
  event.wheel.windowID = 7;
  CHECK(mice.extractor(&event) == 12);

  event.type = SDL_EVENT_MOUSE_MOTION;
  event.motion.which = 13;
  event.motion.windowID = 7;
  CHECK(mice.extractor(&event) == 13);

  event.type = SDL_EVENT_JOYSTICK_AXIS_MOTION;
  event.jaxis.which = 21;
  event.jaxis.axis = 2;
  CHECK(joystickAxis.extractor(&event) == 2);
  CHECK(joysticks.extractor(&event) == 21);

  event.type = SDL_EVENT_JOYSTICK_BALL_MOTION;
  event.jball.which = 22;
  event.jball.ball = 3;
  CHECK(joystickBall.extractor(&event) == 3);
  CHECK(joysticks.extractor(&event) == 22);

  event.type = SDL_EVENT_JOYSTICK_HAT_MOTION;
  event.jhat.which = 23;
  event.jhat.hat = 4;
  CHECK(joystickHat.extractor(&event) == 4);
  CHECK(joysticks.extractor(&event) == 23);

  event.type = SDL_EVENT_JOYSTICK_BUTTON_DOWN;
  event.jbutton.which = 24;
  event.jbutton.button = 5;
  CHECK(joystickButtons.extractor(&event) == 5);
  CHECK(joysticks.extractor(&event) == 24);
  joystickButton.Trigger(&event);

  event.type = SDL_EVENT_JOYSTICK_ADDED;
  event.jdevice.which = 25;
  CHECK(joysticks.extractor(&event) == 25);

  event.type = SDL_EVENT_GAMEPAD_AXIS_MOTION;
  event.gaxis.which = 31;
  event.gaxis.axis = SDL_GAMEPAD_AXIS_LEFTX;
  CHECK(gamepadAxis.extractor(&event) == SDL_GAMEPAD_AXIS_LEFTX);
  CHECK(gamepads.extractor(&event) == 31);

  event.type = SDL_EVENT_GAMEPAD_BUTTON_DOWN;
  event.gbutton.which = 32;
  event.gbutton.button = SDL_GAMEPAD_BUTTON_SOUTH;
  CHECK(gamepadButtons.extractor(&event) == SDL_GAMEPAD_BUTTON_SOUTH);
  CHECK(gamepads.extractor(&event) == 32);
  gamepadButton.Trigger(&event);

  event.type = SDL_EVENT_GAMEPAD_ADDED;
  event.gdevice.which = 33;
  CHECK(gamepads.extractor(&event) == 33);

  event.type = SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN;
  event.gtouchpad.which = 34;
  CHECK(gamepads.extractor(&event) == 34);
  touchpad.Trigger(&event);

  event.type = SDL_EVENT_GAMEPAD_SENSOR_UPDATE;
  event.gsensor.which = 35;
  CHECK(gamepads.extractor(&event) == 35);

  event.type = SDL_EVENT_FINGER_DOWN;
  event.tfinger.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  finger.Trigger(&event);

  event.type = SDL_EVENT_DROP_FILE;
  event.drop.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  drop.Trigger(&event);

  event.type = SDL_EVENT_AUDIO_DEVICE_ADDED;
  audio.Trigger(&event);

  event.type = SDL_EVENT_PEN_PROXIMITY_IN;
  event.pproximity.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  pen.Trigger(&event);

  event.type = SDL_EVENT_PEN_BUTTON_DOWN;
  event.pbutton.windowID = 7;
  CHECK(windows.extractor(&event) == 7);

  event.type = SDL_EVENT_PEN_AXIS;
  event.paxis.windowID = 7;
  CHECK(windows.extractor(&event) == 7);

  event.type = SDL_EVENT_PEN_DOWN;
  event.ptouch.windowID = 7;
  CHECK(windows.extractor(&event) == 7);

  event.type = SDL_EVENT_CAMERA_DEVICE_ADDED;
  camera.Trigger(&event);

  event.type = SDL_EVENT_RENDER_TARGETS_RESET;
  event.render.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  render.Trigger(&event);

  event.type = SDL_EVENT_KEYBOARD_ADDED;
  keyboard.Trigger(&event);

  event.type = SDL_EVENT_TEXT_INPUT;
  event.text.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  text.Trigger(&event);

  event.type = SDL_EVENT_TEXT_EDITING;
  event.edit.windowID = 7;
  CHECK(windows.extractor(&event) == 7);

  event.type = SDL_EVENT_TEXT_EDITING_CANDIDATES;
  event.edit_candidates.windowID = 7;
  CHECK(windows.extractor(&event) == 7);

  event.type = SDL_EVENT_DISPLAY_ADDED;
  displays.Trigger(&event);

  event.type = SDL_EVENT_USER;
  event.user.windowID = 91;
  CHECK(windows.extractor(&event) == 91);

  event.type = SDL_EVENT_FIRST;
  CHECK(windows.extractor(&event) == 0);
}

TEST_CASE("Event router variants and tap lifecycle edges are exercised") {
  SDL_Event event {};
  event.type = SDL_EVENT_TEXT_INPUT;
  CHECK(hdk::sdl::Event::GetDescription<1>(&event) == "BUFFER TOO SMALL");

  hdk::sdl::evt::EventConduit conduit;
  hdk::sdl::evt::EventConduit::Tap emptyTap;
  CHECK_FALSE(emptyTap.IsActive());
  CHECK_FALSE(emptyTap.Detach());
  CHECK_FALSE(emptyTap.Pause());
  CHECK_FALSE(emptyTap.Resume());
  CHECK_FALSE(emptyTap.IsPaused());

  int triggerCount = 0;
  auto firstTap = conduit.Attach([&](SDL_Event*) { ++triggerCount; });
  auto movedTap = std::move(firstTap);
  CHECK(movedTap.IsActive());
  CHECK_FALSE(firstTap.IsActive());
  hdk::sdl::evt::EventConduit::Tap assignedTap;
  assignedTap = std::move(movedTap);
  CHECK(assignedTap.IsActive());
  CHECK_FALSE(movedTap.IsActive());
  conduit(&event);
  CHECK(triggerCount == 1);
  CHECK(assignedTap.Detach());

  hdk::grid::eps::TapScope scope;
  scope.Add(std::move(emptyTap));
  CHECK(scope.Size() == 0);
  auto scopedTap = conduit.Attach([&](SDL_Event*) { ++triggerCount; });
  scope.Add(std::move(scopedTap));
  CHECK(scope.Size() == 1);
  scope.Clear();
  CHECK(scope.Size() == 0);

  hdk::sdl::evt::DisplayEvents displays;
  auto displayTap = displays.Orientation.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_DISPLAY_ORIENTATION;
  displays.Trigger(&event);
  CHECK(displayTap.IsActive());
  event.type = SDL_EVENT_DISPLAY_REMOVED;
  displays.Trigger(&event);
  event.type = SDL_EVENT_DISPLAY_MOVED;
  displays.Trigger(&event);
  event.type = SDL_EVENT_DISPLAY_DESKTOP_MODE_CHANGED;
  displays.Trigger(&event);
  event.type = SDL_EVENT_DISPLAY_CURRENT_MODE_CHANGED;
  displays.Trigger(&event);
  event.type = SDL_EVENT_DISPLAY_CONTENT_SCALE_CHANGED;
  displays.Trigger(&event);

  hdk::sdl::evt::KeysEvents keys;
  hdk::sdl::evt::KeyEvents keyedEvents;
  keys.value_dispatch_map[SDLK_B] = &keyedEvents;
  auto keyDownTap = keyedEvents.Down.Attach([&](SDL_Event*) { ++triggerCount; });
  auto keyUpTap = keyedEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_KEY_DOWN;
  event.key.key = SDLK_B;
  keys.Trigger(&event);
  event.type = SDL_EVENT_KEY_UP;
  keys.Trigger(&event);
  event.type = SDL_EVENT_FIRST;
  event.key.key = 0;
  CHECK(keys.extractor(&event) == 0);
  CHECK(keyDownTap.IsActive());
  CHECK(keyUpTap.IsActive());

  hdk::sdl::evt::JoysticksEvents joysticks;
  hdk::sdl::evt::JoystickEvents joystickEvents;
  hdk::sdl::evt::JoystickButtonEvents joystickButtonEvents;
  joysticks.value_dispatch_map[41] = &joystickEvents;
  joystickEvents.Button.value_dispatch_map[2] = &joystickButtonEvents;
  auto joystickDownTap = joystickButtonEvents.Down.Attach([&](SDL_Event*) { ++triggerCount; });
  auto joystickUpTap = joystickButtonEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto joystickAddedTap = joystickEvents.Added.Attach([&](SDL_Event*) { ++triggerCount; });
  auto joystickRemovedTap = joystickEvents.Removed.Attach([&](SDL_Event*) { ++triggerCount; });
  auto joystickBatteryTap = joystickEvents.BatteryUpdated.Attach([&](SDL_Event*) { ++triggerCount; });
  auto joystickUpdateTap = joystickEvents.UpdateComplete.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_JOYSTICK_BUTTON_DOWN;
  event.jbutton.which = 41;
  event.jbutton.button = 2;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_JOYSTICK_BUTTON_UP;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_JOYSTICK_ADDED;
  event.jdevice.which = 41;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_JOYSTICK_REMOVED;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_JOYSTICK_BATTERY_UPDATED;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_JOYSTICK_UPDATE_COMPLETE;
  joysticks.Trigger(&event);
  event.type = SDL_EVENT_USER;
  CHECK(joysticks.extractor(&event) == -1);
  CHECK(joystickDownTap.IsActive());
  CHECK(joystickUpTap.IsActive());
  CHECK(joystickAddedTap.IsActive());
  CHECK(joystickRemovedTap.IsActive());
  CHECK(joystickBatteryTap.IsActive());
  CHECK(joystickUpdateTap.IsActive());

  hdk::sdl::evt::GamepadsEvents gamepads;
  hdk::sdl::evt::GamepadEvents gamepadEvents;
  hdk::sdl::evt::GamepadButtonEvents gamepadButtonEvents;
  gamepads.value_dispatch_map[51] = &gamepadEvents;
  gamepadEvents.Button.value_dispatch_map[SDL_GAMEPAD_BUTTON_EAST] = &gamepadButtonEvents;
  auto gamepadDownTap = gamepadButtonEvents.Down.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadUpTap = gamepadButtonEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadAddedTap = gamepadEvents.Added.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadRemovedTap = gamepadEvents.Removed.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadRemappedTap = gamepadEvents.Remapped.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadSensorTap = gamepadEvents.SensorUpdate.Attach([&](SDL_Event*) { ++triggerCount; });
  auto gamepadUpdateTap = gamepadEvents.UpdateComplete.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_GAMEPAD_BUTTON_DOWN;
  event.gbutton.which = 51;
  event.gbutton.button = SDL_GAMEPAD_BUTTON_EAST;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_BUTTON_UP;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_ADDED;
  event.gdevice.which = 51;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_REMOVED;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_REMAPPED;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION;
  event.gtouchpad.which = 51;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_TOUCHPAD_UP;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_SENSOR_UPDATE;
  event.gsensor.which = 51;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_UPDATE_COMPLETE;
  gamepads.Trigger(&event);
  event.type = SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED;
  CHECK(gamepads.extractor(&event) == 51);
  event.type = SDL_EVENT_FIRST;
  CHECK(gamepads.extractor(&event) == -1);
  CHECK(gamepadDownTap.IsActive());
  CHECK(gamepadUpTap.IsActive());
  CHECK(gamepadAddedTap.IsActive());
  CHECK(gamepadRemovedTap.IsActive());
  CHECK(gamepadRemappedTap.IsActive());
  CHECK(gamepadSensorTap.IsActive());
  CHECK(gamepadUpdateTap.IsActive());

  hdk::sdl::evt::MiceEvents mice;
  hdk::sdl::evt::MouseEvents mouseEvents;
  hdk::sdl::evt::MouseButtonEvents mouseButtonEvents;
  mice.value_dispatch_map[61] = &mouseEvents;
  mouseEvents.Button.value_dispatch_map[SDL_BUTTON_RIGHT] = &mouseButtonEvents;
  auto mouseDownTap = mouseButtonEvents.Down.Attach([&](SDL_Event*) { ++triggerCount; });
  auto mouseUpTap = mouseButtonEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto mouseMotionTap = mouseEvents.Motion.Attach([&](SDL_Event*) { ++triggerCount; });
  auto mouseWheelTap = mouseEvents.Wheel.Attach([&](SDL_Event*) { ++triggerCount; });
  auto mouseAddedTap = mouseEvents.Added.Attach([&](SDL_Event*) { ++triggerCount; });
  auto mouseRemovedTap = mouseEvents.Removed.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_MOUSE_BUTTON_DOWN;
  event.button.which = 61;
  event.button.button = SDL_BUTTON_RIGHT;
  mice.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_BUTTON_UP;
  mice.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_MOTION;
  event.motion.which = 61;
  mice.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_WHEEL;
  event.wheel.which = 61;
  mice.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_ADDED;
  event.mdevice.which = 61;
  mice.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_REMOVED;
  mice.Trigger(&event);
  event.type = SDL_EVENT_FIRST;
  CHECK(mice.extractor(&event) == -1);
  CHECK(mouseDownTap.IsActive());
  CHECK(mouseUpTap.IsActive());
  CHECK(mouseMotionTap.IsActive());
  CHECK(mouseWheelTap.IsActive());
  CHECK(mouseAddedTap.IsActive());
  CHECK(mouseRemovedTap.IsActive());

  hdk::sdl::evt::WindowsEvents windows;
  auto& windowEvents = windows[7];
  hdk::sdl::evt::KeyEvents windowKeyEvents;
  hdk::sdl::evt::MouseEvents windowMouseEvents;
  hdk::sdl::evt::MouseButtonEvents windowMouseButtonEvents;
  windowEvents.Key.value_dispatch_map[SDLK_C] = &windowKeyEvents;
  windowEvents.Mouse.value_dispatch_map[71] = &windowMouseEvents;
  windowMouseEvents.Button.value_dispatch_map[SDL_BUTTON_MIDDLE] = &windowMouseButtonEvents;
  auto hiddenTap = windowEvents.Hidden.Attach([&](SDL_Event*) { ++triggerCount; });
  auto fingerCanceledTap = windowEvents.Finger.Canceled.Attach([&](SDL_Event*) { ++triggerCount; });
  auto penMotionTap = windowEvents.Pen.Motion.Attach([&](SDL_Event*) { ++triggerCount; });
  auto penUpTap = windowEvents.Pen.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto textEditingTap = windowEvents.Text.Editing.Attach([&](SDL_Event*) { ++triggerCount; });
  auto textCandidatesTap = windowEvents.Text.EditingCandidates.Attach([&](SDL_Event*) { ++triggerCount; });
  auto dropCompleteTap = windowEvents.Drop.Complete.Attach([&](SDL_Event*) { ++triggerCount; });
  auto renderLostTap = windowEvents.Render.DeviceLost.Attach([&](SDL_Event*) { ++triggerCount; });
  auto windowKeyUpTap = windowKeyEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto windowMouseUpTap = windowMouseButtonEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_WINDOW_HIDDEN;
  event.window.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_FINGER_CANCELED;
  event.tfinger.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_PEN_MOTION;
  event.pbutton.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_PEN_UP;
  event.ptouch.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_TEXT_EDITING;
  event.edit.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_TEXT_EDITING_CANDIDATES;
  event.edit_candidates.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_DROP_COMPLETE;
  event.drop.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_RENDER_DEVICE_LOST;
  event.render.windowID = 7;
  windows.Trigger(&event);
  event.type = SDL_EVENT_KEY_UP;
  event.key.windowID = 7;
  event.key.key = SDLK_C;
  windows.Trigger(&event);
  event.type = SDL_EVENT_MOUSE_BUTTON_UP;
  event.button.windowID = 7;
  event.button.which = 71;
  event.button.button = SDL_BUTTON_MIDDLE;
  windows.Trigger(&event);
  event.type = SDL_EVENT_PEN_PROXIMITY_OUT;
  event.pproximity.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  event.type = SDL_EVENT_MOUSE_WHEEL;
  event.wheel.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  event.type = SDL_EVENT_MOUSE_BUTTON_DOWN;
  event.button.windowID = 7;
  CHECK(windows.extractor(&event) == 7);
  CHECK(hiddenTap.IsActive());
  CHECK(fingerCanceledTap.IsActive());
  CHECK(penMotionTap.IsActive());
  CHECK(penUpTap.IsActive());
  CHECK(textEditingTap.IsActive());
  CHECK(textCandidatesTap.IsActive());
  CHECK(dropCompleteTap.IsActive());
  CHECK(renderLostTap.IsActive());
  CHECK(windowKeyUpTap.IsActive());
  CHECK(windowMouseUpTap.IsActive());

  hdk::sdl::evt::AllTypes allTypes;
  hdk::sdl::evt::WindowEvents& allWindow = allTypes.Window[7];
  hdk::sdl::evt::KeyEvents allWindowKeyEvents;
  allWindow.Key.value_dispatch_map[SDLK_D] = &allWindowKeyEvents;
  auto quitTap = allTypes.Quit.Attach([&](SDL_Event*) { ++triggerCount; });
  auto clipboardTap = allTypes.ClipboardUpdate.Attach([&](SDL_Event*) { ++triggerCount; });
  auto sensorTap = allTypes.SensorUpdate.Attach([&](SDL_Event*) { ++triggerCount; });
  auto allKeyUpTap = allWindowKeyEvents.Up.Attach([&](SDL_Event*) { ++triggerCount; });
  auto allDropTextTap = allWindow.Drop.Text.Attach([&](SDL_Event*) { ++triggerCount; });
  auto allRenderResetTap = allWindow.Render.DeviceReset.Attach([&](SDL_Event*) { ++triggerCount; });
  event.type = SDL_EVENT_QUIT;
  allTypes.Trigger(&event);
  event.type = SDL_EVENT_CLIPBOARD_UPDATE;
  allTypes.Trigger(&event);
  event.type = SDL_EVENT_SENSOR_UPDATE;
  allTypes.Trigger(&event);
  event.type = SDL_EVENT_KEY_UP;
  event.key.windowID = 7;
  event.key.key = SDLK_D;
  allTypes.Trigger(&event);
  event.type = SDL_EVENT_DROP_TEXT;
  event.drop.windowID = 7;
  allTypes.Trigger(&event);
  event.type = SDL_EVENT_RENDER_DEVICE_RESET;
  event.render.windowID = 7;
  allTypes.Trigger(&event);
  CHECK(quitTap.IsActive());
  CHECK(clipboardTap.IsActive());
  CHECK(sensorTap.IsActive());
  CHECK(allKeyUpTap.IsActive());
  CHECK(allDropTextTap.IsActive());
  CHECK(allRenderResetTap.IsActive());
}