tests/core/test_waitable_handle_watch.cpp

   1 /*
   2  * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        test_waitable_handle_watch.cpp
  18  * @author      Slawomir Pajak (s.pajak@partner.samsung.com)
  19  * @version     1.0
  20  * @brief       This file is the implementation file of WaitableHandleWatchSupport tests
  21  */
  22 #include <dpl/test/test_runner.h>
  23
  24 RUNNER_TEST_GROUP_INIT(DPL)
  25
  26 using namespace DPL;
  27
  28 class TestListener: public WaitableHandleWatchSupport::WaitableHandleListener {
  29 public:
  30     int listenerHitCount;
  31     TestListener() :
  32             listenerHitCount(0)
  33     {
  34     }
  35     virtual ~TestListener()
  36     {
  37     }
  38     virtual void OnWaitableHandleEvent(WaitableHandle /*waitableHandle*/, WaitMode::Type /*mode*/)
  39     {
  40         listenerHitCount++;
  41     }
  42 };
  43
  44 class TestWaitableHandleWatch: public WaitableHandleWatchSupport {
  45 public:
  46     virtual ~TestWaitableHandleWatch()
  47     {
  48     }
  49
  50     virtual Thread *GetInvokerThread()
  51     {
  52         return Thread::GetCurrentThread();
  53     }
  54
  55     // Invoke direct invoker
  56     virtual void HandleDirectInvoker()
  57     {
  58
  59     }
  60
  61     using WaitableHandleWatchSupport::HandleWatcher;
  62 };
  63
  64 /*
  65  Name: WaitableHandleWatchSupport_SingleListener
  66  Description: tests WaitableHandleWatchSupport simple case
  67  Expected: listener is notified
  68  */
  69 RUNNER_TEST(WaitableHandleWatchSupport_SingleListener)
  70 {
  71     TestWaitableHandleWatch handleWatch;
  72     WaitableHandle handle = 1;
  73     TestListener listener;
  74     handleWatch.AddWaitableHandleWatch(&listener, handle, WaitMode::Read);
  75
  76     handleWatch.HandleWatcher(handle, WaitMode::Read);
  77     RUNNER_ASSERT(1 == listener.listenerHitCount);
  78 }
  79
  80 /*
  81  Name: WaitableHandleWatchSupport_MultipleListener
  82  Description: tests WaitableHandleWatchSupport multiple listeners
  83  Expected: listeners are notified correctly
  84  */
  85 RUNNER_TEST(WaitableHandleWatchSupport_MultipleListener)
  86 {
  87     TestWaitableHandleWatch handleWatch;
  88     WaitableHandle handle = 1;
  89     TestListener listenerR1;
  90     TestListener listenerR2;
  91     TestListener listenerW1;
  92     TestListener listenerW2;
  93     handleWatch.AddWaitableHandleWatch(&listenerR1, handle, WaitMode::Read);
  94     handleWatch.AddWaitableHandleWatch(&listenerR2, handle, WaitMode::Read);
  95     handleWatch.AddWaitableHandleWatch(&listenerW1, handle, WaitMode::Write);
  96     handleWatch.AddWaitableHandleWatch(&listenerW2, handle, WaitMode::Write);
  97
  98     handleWatch.HandleWatcher(handle, WaitMode::Read);
  99     RUNNER_ASSERT(1 == listenerR1.listenerHitCount);
 100     RUNNER_ASSERT(1 == listenerR2.listenerHitCount);
 101     RUNNER_ASSERT(0 == listenerW1.listenerHitCount);
 102     RUNNER_ASSERT(0 == listenerW2.listenerHitCount);
 103
 104     handleWatch.HandleWatcher(handle, WaitMode::Write);
 105     RUNNER_ASSERT(1 == listenerR1.listenerHitCount);
 106     RUNNER_ASSERT(1 == listenerR2.listenerHitCount);
 107     RUNNER_ASSERT(1 == listenerW1.listenerHitCount);
 108     RUNNER_ASSERT(1 == listenerW2.listenerHitCount);
 109 }
 110
 111 /*
 112  Name: WaitableHandleWatchSupport_MultipleHandle
 113  Description: tests WaitableHandleWatchSupport multiple handles
 114  Expected: listeners are notified correctly
 115  */
 116 RUNNER_TEST(WaitableHandleWatchSupport_MultipleHandle)
 117 {
 118     TestWaitableHandleWatch handleWatch;
 119     TestListener listener;
 120     WaitableHandle handle1 = 1;
 121     WaitableHandle handle2 = 2;
 122     handleWatch.AddWaitableHandleWatch(&listener, handle1, WaitMode::Read);
 123     handleWatch.AddWaitableHandleWatch(&listener, handle2, WaitMode::Read);
 124     handleWatch.AddWaitableHandleWatch(&listener, handle1, WaitMode::Write);
 125     handleWatch.AddWaitableHandleWatch(&listener, handle2, WaitMode::Write);
 126
 127     handleWatch.HandleWatcher(handle1, WaitMode::Read);
 128     RUNNER_ASSERT(1 == listener.listenerHitCount);
 129
 130     handleWatch.HandleWatcher(handle1, WaitMode::Write);
 131     RUNNER_ASSERT(2 == listener.listenerHitCount);
 132
 133     handleWatch.HandleWatcher(handle2, WaitMode::Read);
 134     RUNNER_ASSERT(3 == listener.listenerHitCount);
 135
 136     handleWatch.HandleWatcher(handle2, WaitMode::Write);
 137     RUNNER_ASSERT(4 == listener.listenerHitCount);
 138 }
 139
 140 /*
 141  Name: WaitableHandleWatchSupport_AddRemoveListener
 142  Description: tests WaitableHandleWatchSupport removing listeners function
 143  Expected: remaining listeners are notified correctly, removed are not notified
 144  */
 145 RUNNER_TEST(WaitableHandleWatchSupport_AddRemoveListener)
 146 {
 147     TestWaitableHandleWatch handleWatch;
 148     TestListener listener;
 149     WaitableHandle handle1 = 1;
 150     WaitableHandle handle2 = 2;
 151     handleWatch.AddWaitableHandleWatch(&listener, handle1, WaitMode::Read);
 152     handleWatch.AddWaitableHandleWatch(&listener, handle2, WaitMode::Read);
 153     handleWatch.AddWaitableHandleWatch(&listener, handle1, WaitMode::Write);
 154     handleWatch.AddWaitableHandleWatch(&listener, handle2, WaitMode::Write);
 155
 156     handleWatch.HandleWatcher(handle1, WaitMode::Read);
 157     RUNNER_ASSERT(1 == listener.listenerHitCount);
 158
 159     handleWatch.RemoveWaitableHandleWatch(&listener, handle1, WaitMode::Write);
 160     handleWatch.HandleWatcher(handle1, WaitMode::Write);
 161     RUNNER_ASSERT(1 == listener.listenerHitCount);
 162
 163     handleWatch.RemoveWaitableHandleWatch(&listener, handle2, WaitMode::Read);
 164     handleWatch.HandleWatcher(handle2, WaitMode::Read);
 165     RUNNER_ASSERT(1 == listener.listenerHitCount);
 166
 167     handleWatch.HandleWatcher(handle2, WaitMode::Write);
 168     RUNNER_ASSERT(2 == listener.listenerHitCount);
 169 }