toolkit/qa/cppunit/a11y/XAccessibleEventBroadcasterTester.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "XAccessibleEventBroadcasterTester.hxx"
  21
  22 #include <iostream>
  23
  24 #include <cppunit/TestAssert.h>
  25
  26 #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
  27 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  28 #include <com/sun/star/accessibility/XAccessible.hpp>
  29 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  30 #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp>
  31 #include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
  32 #include <com/sun/star/awt/PosSize.hpp>
  33 #include <com/sun/star/awt/Rectangle.hpp>
  34 #include <com/sun/star/awt/XWindow.hpp>
  35 #include <com/sun/star/lang/EventObject.hpp>
  36
  37 #include <cppuhelper/implbase.hxx>
  38 #include <rtl/ref.hxx>
  39 #include <sal/log.hxx>
  40
  41 #include <test/a11y/AccessibilityTools.hxx>
  42
  43 using namespace css;
  44
  45 namespace
  46 {
  47 class EvListener : public cppu::WeakImplHelper<accessibility::XAccessibleEventListener>
  48 {
  49 public:
  50     bool mbGotEvent;
  51
  52     EvListener()
  53         : mbGotEvent(false)
  54     {
  55     }
  56
  57     // XEventListener
  58     virtual void SAL_CALL disposing(const lang::EventObject&) override {}
  59
  60     // XAccessibleEventListener
  61     virtual void SAL_CALL notifyEvent(const accessibility::AccessibleEventObject& aEvent) override
  62     {
  63         std::cout << "Listener got event: " << AccessibilityTools::debugString(aEvent) << std::endl;
  64         uno::Reference<accessibility::XAccessible> xOld(aEvent.OldValue, uno::UNO_QUERY);
  65         if (xOld.is())
  66             std::cout << "Old: " << AccessibilityTools::debugString(xOld) << std::endl;
  67
  68         uno::Reference<accessibility::XAccessible> xNew(aEvent.NewValue, uno::UNO_QUERY);
  69         if (xNew.is())
  70             std::cout << "New: " << AccessibilityTools::debugString(xNew) << std::endl;
  71
  72         mbGotEvent = true;
  73     }
  74 };
  75 }
  76
  77 XAccessibleEventBroadcasterTester::XAccessibleEventBroadcasterTester(
  78     const uno::Reference<accessibility::XAccessibleEventBroadcaster>& xBroadcaster,
  79     const uno::Reference<awt::XWindow>& xWindow)
  80     : mxBroadcaster(xBroadcaster)
  81     , mxWindow(xWindow)
  82 {
  83 }
  84
  85 bool XAccessibleEventBroadcasterTester::isTransient(
  86     const uno::Reference<accessibility::XAccessibleEventBroadcaster> xBroadcaster)
  87 {
  88     uno::Reference<accessibility::XAccessibleContext> xCtx(xBroadcaster, uno::UNO_QUERY_THROW);
  89     return isTransient(xCtx);
  90 }
  91
  92 bool XAccessibleEventBroadcasterTester::isTransient(
  93     const uno::Reference<accessibility::XAccessibleContext> xCtx)
  94 {
  95     return ((xCtx->getAccessibleStateSet() & accessibility::AccessibleStateType::TRANSIENT)
  96             && (xCtx->getAccessibleParent()->getAccessibleContext()->getAccessibleStateSet()
  97                 & accessibility::AccessibleStateType::MANAGES_DESCENDANTS));
  98 }
  99
 100 /**
 101  * @brief Generates an event on @c mxBroadcaster.
 102  *
 103  * This method indirectly alters the state of @c mxBroadcaster so that an
 104  * accessible event will be fired for it.  It can be called as many times as
 105  * needed and triggers an event each time.
 106  */
 107 void XAccessibleEventBroadcasterTester::fireEvent()
 108 {
 109     awt::Rectangle newPosSize = mxWindow->getPosSize();
 110     newPosSize.Width = newPosSize.Width - 20;
 111     newPosSize.Height = newPosSize.Height - 20;
 112     newPosSize.X = newPosSize.X + 20;
 113     newPosSize.Y = newPosSize.Y + 20;
 114     mxWindow->setPosSize(newPosSize.X, newPosSize.Y, newPosSize.Width, newPosSize.Height,
 115                          awt::PosSize::POSSIZE);
 116 }
 117
 118 /**
 119  * @brief Adds a listener and fires events by mean of object relation.
 120  *
 121  * Asserts that the listener was properly called.
 122  */
 123 void XAccessibleEventBroadcasterTester::testAddEventListener()
 124 {
 125     rtl::Reference<EvListener> xListener(new EvListener);
 126     mxBroadcaster->addAccessibleEventListener(xListener);
 127     bool transient = isTransient(mxBroadcaster);
 128
 129     std::cout << "firing event" << std::endl;
 130     fireEvent();
 131
 132     AccessibilityTools::Await([&xListener]() { return xListener->mbGotEvent; });
 133
 134     if (!transient)
 135         CPPUNIT_ASSERT_MESSAGE("listener wasn't called", xListener->mbGotEvent);
 136     else
 137         CPPUNIT_ASSERT_MESSAGE("Object is Transient, listener isn't expected to be called",
 138                                !xListener->mbGotEvent);
 139
 140     mxBroadcaster->removeAccessibleEventListener(xListener);
 141 }
 142
 143 /**
 144  * @brief Similar to @c testAddEventListener() but also removes the listener
 145  *
 146  * Adds an event listener just like @c testAddEventListener(), and then removes it and verifies an
 147  * event doesn't trigger the supposedly removed listener.
 148  *
 149  * @see testAddEventListener()
 150  */
 151 void XAccessibleEventBroadcasterTester::testRemoveEventListener()
 152 {
 153     /* there is nothing we can really test for transient objects */
 154     if (isTransient(mxBroadcaster))
 155     {
 156         std::cerr << "could not test removing listener on transient object " << mxBroadcaster
 157                   << std::endl;
 158         return;
 159     }
 160
 161     rtl::Reference<EvListener> xListener(new EvListener);
 162     mxBroadcaster->addAccessibleEventListener(xListener);
 163
 164     std::cout << "firing event (with listener)" << std::endl;
 165     fireEvent();
 166
 167     AccessibilityTools::Await([&xListener]() { return xListener->mbGotEvent; });
 168
 169     CPPUNIT_ASSERT_MESSAGE("listener wasn't called", xListener->mbGotEvent);
 170
 171     /* reset listener, remove it and try again */
 172     xListener->mbGotEvent = false;
 173
 174     std::cout << "removing listener" << std::endl;
 175     mxBroadcaster->removeAccessibleEventListener(xListener);
 176
 177     std::cout << "firing event (without listener)" << std::endl;
 178     fireEvent();
 179
 180     AccessibilityTools::Wait(500);
 181
 182     CPPUNIT_ASSERT_MESSAGE("removed listener was called", !xListener->mbGotEvent);
 183 }
 184
 185 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */