vcl/source/window/debugevent.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <comphelper/random.hxx>
  11 #include <rtl/math.hxx>
  12 #include <rtl/string.hxx>
  13 #include <tools/time.hxx>
  14 #include <vcl/keycodes.hxx>
  15 #include <vcl/svapp.hxx>
  16 #include <vcl/debugevent.hxx>
  17 #include <vcl/wrkwin.hxx>
  18 #include <vcl/menu.hxx>
  19 #include "window.h"
  20 #include "salwtype.hxx"
  21
  22 #if OSL_DEBUG_LEVEL > 0
  23
  24 DebugEventInjector::DebugEventInjector( sal_uInt32 nMaxEvents) :
  25       Timer("debug event injector")
  26     , mnEventsLeft( nMaxEvents )
  27 {
  28     SetTimeout( 1000 /* ms */ );
  29     Start();
  30 }
  31
  32 static double getRandom()
  33 {
  34     return comphelper::rng::uniform_real_distribution();
  35 }
  36
  37 vcl::Window *DebugEventInjector::ChooseWindow()
  38 {
  39     vcl::Window *pWindow, *pParent;
  40
  41     if (getRandom() < 0.80 &&
  42         (pWindow = Application::GetFocusWindow()))
  43         return pWindow;
  44
  45     if (getRandom() > 0.50 ||
  46         !(pParent = Application::GetActiveTopWindow()))
  47     {
  48         // select a top window at random
  49         long nIdx = Application::GetTopWindowCount() * getRandom();
  50         if (!(pParent = Application::GetTopWindow( nIdx )))
  51             pParent = static_cast<vcl::Window *>(Application::GetAppWindow());
  52     }
  53     assert (pParent != nullptr);
  54
  55     std::vector< vcl::Window *> aChildren;
  56     pParent->CollectChildren( aChildren );
  57
  58     return aChildren[ aChildren.size() * getRandom() ];
  59 }
  60
  61
  62 static void CollectMenuItemIds( Menu *pMenu, std::vector< SalMenuEvent > &rIds )
  63 {
  64     sal_uInt16 nItems = pMenu->GetItemCount();
  65     for (sal_uInt16 i = 0; i < nItems; i++)
  66     {
  67         if (pMenu->GetItemType( i ) != MenuItemType::SEPARATOR || getRandom() < 0.01)
  68             rIds.push_back( SalMenuEvent( pMenu->GetItemId( i ), pMenu ) );
  69         PopupMenu *pPopup = pMenu->GetPopupMenu( i );
  70         if (pPopup)
  71             CollectMenuItemIds( pPopup, rIds );
  72     }
  73 }
  74
  75 void DebugEventInjector::InjectMenuEvent()
  76 {
  77     vcl::Window *pFocus = Application::GetFocusWindow();
  78     if (!pFocus)
  79         return;
  80
  81     SystemWindow *pSysWin = pFocus->GetSystemWindow();
  82     if (!pSysWin)
  83         return;
  84
  85     MenuBar *pMenuBar = pSysWin->GetMenuBar();
  86     if (!pMenuBar)
  87         return;
  88
  89     SalEvent nEvents[] = {
  90         SalEvent::MenuCommand,
  91         SalEvent::MenuCommand,
  92         SalEvent::MenuActivate,
  93         SalEvent::MenuDeactivate,
  94         SalEvent::MenuHighlight,
  95         SalEvent::MenuCommand,
  96         SalEvent::MenuCommand,
  97         SalEvent::MenuCommand,
  98         SalEvent::MenuButtonCommand,
  99         SalEvent::MenuButtonCommand,
 100     };
 101
 102     std::vector< SalMenuEvent > aIds;
 103     CollectMenuItemIds( pMenuBar, aIds );
 104
 105     SalEvent nEvent = nEvents[ (int)(getRandom() * SAL_N_ELEMENTS( nEvents )) ];
 106     SalMenuEvent aEvent = aIds[ getRandom() * aIds.size() ];
 107     bool bHandled = ImplWindowFrameProc( pSysWin, nEvent, &aEvent);
 108
 109     SAL_INFO( "vcl.debugevent",
 110               "Injected menu event " << aEvent.mpMenu
 111               << " (" << aEvent.mnId << ") '"
 112               << static_cast<Menu *>(aEvent.mpMenu)->GetItemText( aEvent.mnId ) << "' -> "
 113               << bHandled );
 114 }
 115
 116 static void InitKeyEvent( SalKeyEvent &rKeyEvent )
 117 {
 118     double nRand = getRandom();
 119     if (nRand < 0.001)
 120         rKeyEvent.mnTime = getRandom() * SAL_MAX_UINT64;
 121     else
 122         rKeyEvent.mnTime = tools::Time::GetSystemTicks();
 123
 124     if (getRandom() < 0.01)
 125         rKeyEvent.mnRepeat = getRandom() * 20;
 126     else
 127         rKeyEvent.mnRepeat = 0;
 128 }
 129
 130 void DebugEventInjector::InjectTextEvent()
 131 {
 132     SalKeyEvent aKeyEvent;
 133     vcl::Window *pWindow = ChooseWindow();
 134
 135     InitKeyEvent( aKeyEvent );
 136
 137     if (getRandom() < 0.10) // Occasionally a truly random event
 138     {
 139         aKeyEvent.mnCode = getRandom() * KEY_CODE_MASK;
 140         aKeyEvent.mnCharCode = getRandom() * 0xffff;
 141     }
 142     else
 143     {
 144         struct {
 145             sal_uInt16 nCodeStart, nCodeEnd;
 146             char       aCharStart;
 147         } nTextCodes[] = {
 148             { KEY_0, KEY_9, '0' },
 149             { KEY_A, KEY_Z, 'a' }
 150         };
 151
 152         size_t i = getRandom() * SAL_N_ELEMENTS( nTextCodes );
 153         int offset = int( getRandom() * ( nTextCodes[i].nCodeEnd - nTextCodes[i].nCodeStart ) );
 154         aKeyEvent.mnCode = nTextCodes[i].nCodeStart + offset;
 155         aKeyEvent.mnCharCode = nTextCodes[i].aCharStart + offset;
 156 //        fprintf( stderr, "Char '%c' offset %d into record %d base '%c'\n",
 157 //                 aKeyEvent.mnCharCode, offset, (int)i, nTextCodes[i].aCharStart );
 158     }
 159
 160     if( getRandom() < 0.05 ) // modifier
 161         aKeyEvent.mnCode |= (sal_uInt16)( getRandom() * KEY_MODIFIERS_MASK ) & KEY_MODIFIERS_MASK;
 162
 163     bool bHandled = ImplWindowFrameProc( pWindow, SalEvent::KeyInput, &aKeyEvent);
 164
 165     SAL_INFO( "vcl.debugevent",
 166               "Injected key 0x" << std::hex << (int) aKeyEvent.mnCode << std::dec
 167               << " -> " << bHandled
 168               << " win " << pWindow );
 169
 170     ImplWindowFrameProc( pWindow, SalEvent::KeyUp, &aKeyEvent );
 171 }
 172
 173 /*
 174  *   The more heuristics we have to inform this the better,
 175  * key-bindings, menu entries, allowable entry types etc.
 176  */
 177 void DebugEventInjector::InjectEvent()
 178 {
 179 //    fprintf( stderr, "%6d - ", (int)mnEventsLeft );
 180
 181     double nRand = getRandom();
 182     if (nRand < 0.30)
 183     {
 184         int nEvents = getRandom() * 10;
 185         for (int i = 0; i < nEvents; i++)
 186             InjectTextEvent();
 187     }
 188     else if (nRand < 0.60)
 189         InjectKeyNavEdit();
 190     else if (nRand < 0.95)
 191         InjectMenuEvent();
 192 }
 193
 194 void DebugEventInjector::InjectKeyNavEdit()
 195 {
 196     vcl::Window *pWindow = ChooseWindow();
 197
 198     struct {
 199         double     mnProb;
 200         sal_uInt16 mnKey;
 201     } nWeights[] = {
 202         // edit / escape etc. - 50%
 203         { 0.20, KEY_SPACE },
 204         { 0.10, KEY_TAB },
 205         { 0.07, KEY_RETURN },
 206         { 0.05, KEY_DELETE },
 207         { 0.05, KEY_BACKSPACE },
 208
 209         // navigate - 45%
 210         { 0.15, KEY_LEFT },
 211         { 0.10, KEY_RIGHT },
 212         { 0.05, KEY_UP },
 213         { 0.05, KEY_DOWN },
 214         { 0.05, KEY_PAGEUP },
 215         { 0.05, KEY_PAGEDOWN },
 216
 217         // other
 218         { 0.01, KEY_INSERT },
 219         { 0.02, KEY_HOME },
 220         { 0.02, KEY_END },
 221     };
 222
 223     double d = 0.0, nRand = getRandom();
 224     sal_uInt16 nKey = KEY_SPACE;
 225     for (auto & rWeight : nWeights)
 226     {
 227         d += rWeight.mnProb;
 228         assert (d < 1.01);
 229         if ( nRand < d )
 230         {
 231             nKey = rWeight.mnKey;
 232             break;
 233         }
 234     }
 235
 236     SalKeyEvent aKeyEvent;
 237     InitKeyEvent( aKeyEvent );
 238     aKeyEvent.mnCode = nKey;
 239
 240     if (getRandom() < 0.15) // modifier
 241         aKeyEvent.mnCode |= (sal_uInt16)(getRandom() * KEY_MODIFIERS_MASK) & KEY_MODIFIERS_MASK;
 242
 243     aKeyEvent.mnCharCode = 0x0; // hopefully unused.
 244
 245     bool bHandled = ImplWindowFrameProc( pWindow, SalEvent::KeyInput, &aKeyEvent );
 246
 247     SAL_INFO( "vcl.debugevent",
 248               "Injected edit / move key 0x" << std::hex << (int) aKeyEvent.mnCode << std::dec
 249               << " -> " << bHandled
 250               << " win " <<  pWindow );
 251     ImplWindowFrameProc( pWindow, SalEvent::KeyUp, &aKeyEvent );
 252 }
 253
 254 void DebugEventInjector::Invoke()
 255 {
 256     InjectEvent();
 257     mnEventsLeft--;
 258     if (mnEventsLeft > 0)
 259     {
 260         SetTimeout( 1 );
 261         Start();
 262     }
 263     else
 264         Application::Quit();
 265 }
 266
 267 DebugEventInjector *DebugEventInjector::getCreate()
 268 {
 269     sal_uInt32 nEvents;
 270     const char *pEvents = getenv("VCL_EVENT_INJECTION");
 271     if (!pEvents)
 272         return nullptr;
 273     nEvents = OString( pEvents ).toUInt32();
 274     if (nEvents > 0)
 275         return new DebugEventInjector( nEvents );
 276     else
 277         return nullptr;
 278 }
 279
 280 #endif // OSL_DEBUG_LEVEL > 0
 281
 282 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */