sal/qa/osl/condition/osl_Condition.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  * 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 "osl_Condition_Const.h"
  21 #include <stdlib.h>
  22
  23 using namespace osl;
  24
  25 namespace {
  26
  27 enum ConditionType
  28 {
  29     thread_type_set,
  30     thread_type_reset,
  31     thread_type_wait
  32 };
  33
  34 /** thread for testing Condition.
  35  */
  36 class ConditionThread : public Thread
  37 {
  38 public:
  39     //get the Condition to operate
  40     ConditionThread( ::osl::Condition& Con, ConditionType tType): m_MyCon( Con ), m_MyType( tType ) { }
  41
  42 protected:
  43     ::osl::Condition& m_MyCon;
  44     ConditionType m_MyType;
  45
  46     void SAL_CALL run() override
  47     {
  48         switch ( m_MyType )
  49         {
  50             case thread_type_wait:
  51                 m_MyCon.wait(); break;
  52             case thread_type_set:
  53                 m_MyCon.set(); break;
  54             case thread_type_reset:
  55                 m_MyCon.reset(); break;
  56             default:
  57                 break;
  58         }
  59     }
  60 };
  61
  62 }
  63
  64 namespace osl_Condition
  65 {
  66     /** testing the method:
  67         Condition()
  68     */
  69     class ctors : public CppUnit::TestFixture
  70     {
  71     public:
  72         bool bRes, bRes1;
  73
  74         void ctors_create()
  75         {
  76             ::osl::Condition aCond;
  77             bRes = aCond.check();
  78
  79             CPPUNIT_ASSERT_MESSAGE("#test comment#: create a condition its initial check state should be sal_False.",
  80                                    !bRes );
  81         }
  82
  83         void ctors_createAndSet()
  84         {
  85             ::osl::Condition aCond;
  86             aCond.set();
  87             bRes = aCond.check();
  88
  89             CPPUNIT_ASSERT_MESSAGE("#test comment#: create a condition and set it.",
  90                                    bRes );
  91         }
  92
  93         CPPUNIT_TEST_SUITE(ctors);
  94         CPPUNIT_TEST(ctors_create);
  95         CPPUNIT_TEST(ctors_createAndSet);
  96         CPPUNIT_TEST_SUITE_END();
  97     };
  98
  99     /** testing the method:
 100         void set()
 101     */
 102     class set : public CppUnit::TestFixture
 103     {
 104     public:
 105         bool bRes, bRes1, bRes2;
 106
 107         void set_createAndSet()
 108         {
 109             ::osl::Condition aCond;
 110             aCond.set();
 111             bRes = aCond.check();
 112
 113             CPPUNIT_ASSERT_MESSAGE("#test comment#: check state should be sal_True after set.",
 114                                    bRes );
 115         }
 116
 117         void set_threadWaitRelease()
 118         {
 119             ::osl::Condition aCond;
 120             ConditionThread myThread1(aCond, thread_type_wait);
 121             myThread1.create();
 122             bRes = myThread1.isRunning();
 123
 124             ConditionThread myThread2(aCond, thread_type_set);
 125             myThread2.create();
 126
 127             myThread1.join();
 128             bRes1 = myThread1.isRunning();
 129             bRes2 = aCond.check();
 130             myThread2.join();
 131
 132             CPPUNIT_ASSERT_MESSAGE("#test comment#: use one thread to set the condition in order to release another thread.",
 133                                    bRes);
 134             CPPUNIT_ASSERT_MESSAGE("#test comment#: use one thread to set the condition in order to release another thread.",
 135                                    !bRes1);
 136             CPPUNIT_ASSERT_MESSAGE( "#test comment#: use one thread to set the condition in order to release another thread.",
 137                                    bRes2);
 138         }
 139
 140         CPPUNIT_TEST_SUITE(set);
 141         CPPUNIT_TEST(set_createAndSet);
 142         CPPUNIT_TEST(set_threadWaitRelease);
 143         CPPUNIT_TEST_SUITE_END( );
 144     };
 145
 146     /** testing the method:
 147         void reset()
 148     */
 149     class reset : public CppUnit::TestFixture
 150     {
 151     public:
 152         bool bRes, bRes1, bRes2;
 153
 154         void reset_resetWaitAndSet()
 155         {
 156             ::osl::Condition aCond;
 157             aCond.reset();
 158
 159             ConditionThread myThread(aCond, thread_type_wait);
 160             myThread.create();
 161             bRes = myThread.isRunning();
 162             bRes2 = aCond.check();
 163
 164             aCond.set();
 165             myThread.join();
 166             bRes1 = myThread.isRunning();
 167
 168             CPPUNIT_ASSERT_MESSAGE("#test comment#: wait will cause a reset thread block, use set to release it.",
 169                                    bRes);
 170             CPPUNIT_ASSERT_MESSAGE("#test comment#: wait will cause a reset thread block, use set to release it.",
 171                                    !bRes1);
 172             CPPUNIT_ASSERT_MESSAGE("#test comment#: wait will cause a reset thread block, use set to release it.",
 173                                    !bRes2);
 174         }
 175
 176         void reset_resetAndSet()
 177         {
 178             ::osl::Condition aCond;
 179             aCond.reset();
 180             bRes = aCond.check();
 181             aCond.set();
 182             bRes1 = aCond.check();
 183
 184             CPPUNIT_ASSERT_MESSAGE("#test comment#: create a condition and reset/set it.",
 185                                    !bRes );
 186             CPPUNIT_ASSERT_MESSAGE("#test comment#: create a condition and reset/set it.",
 187                                    bRes1 );
 188         }
 189
 190         CPPUNIT_TEST_SUITE(reset);
 191         CPPUNIT_TEST(reset_resetWaitAndSet);
 192         CPPUNIT_TEST(reset_resetAndSet);
 193         CPPUNIT_TEST_SUITE_END();
 194     };
 195
 196     /** testing the method:
 197         Result wait(const TimeValue *pTimeout = 0)
 198     */
 199     class wait : public CppUnit::TestFixture
 200     {
 201     public:
 202         bool bRes, bRes1, bRes2;
 203         std::unique_ptr<TimeValue> tv1;
 204
 205         void setUp() override
 206         {
 207             tv1.reset(new TimeValue);
 208             tv1->Seconds = 1;
 209             tv1->Nanosec = 0;
 210         }
 211
 212         void tearDown() override
 213         {
 214             tv1.reset();
 215         }
 216
 217         void wait_testAllCombos( )
 218         {
 219             ::osl::Condition cond1;
 220             ::osl::Condition cond2;
 221             ::osl::Condition cond3;
 222
 223             cond1.set();
 224             cond2.set();
 225
 226             osl::Condition::Result r1=cond1.wait(tv1.get());
 227             osl::Condition::Result r2=cond2.wait();
 228             osl::Condition::Result r3=cond3.wait(tv1.get());
 229
 230             CPPUNIT_ASSERT_EQUAL_MESSAGE( "#test comment#: test three types of wait.",
 231                                     ::osl::Condition::result_ok, r1 );
 232             CPPUNIT_ASSERT_EQUAL_MESSAGE( "#test comment#: test three types of wait.",
 233                                     ::osl::Condition::result_ok, r2 );
 234             CPPUNIT_ASSERT_EQUAL_MESSAGE( "#test comment#: test three types of wait.",
 235                                     ::osl::Condition::result_timeout, r3 );
 236         }
 237
 238         void wait_timeoutWaits()
 239         {
 240             ::osl::Condition aCond;
 241             ::osl::Condition::Result wRes, wRes1;
 242
 243             aCond.reset();
 244             bRes = aCond.check();
 245             wRes = aCond.wait(tv1.get());
 246
 247             aCond.set();
 248             wRes1 = aCond.wait(tv1.get());
 249             bRes1 = aCond.check();
 250
 251             CPPUNIT_ASSERT_MESSAGE("#test comment#: wait a condition after set/reset.",
 252                                    !bRes );
 253             CPPUNIT_ASSERT_MESSAGE("#test comment#: wait a condition after set/reset.",
 254                                    bRes1 );
 255             CPPUNIT_ASSERT_EQUAL_MESSAGE("#test comment#: wait a condition after set/reset.",
 256                                    ::osl::Condition::result_timeout, wRes );
 257             CPPUNIT_ASSERT_EQUAL_MESSAGE("#test comment#: wait a condition after set/reset.",
 258                                    ::osl::Condition::result_ok, wRes1 );
 259         }
 260
 261         CPPUNIT_TEST_SUITE(wait);
 262         CPPUNIT_TEST(wait_testAllCombos);
 263         CPPUNIT_TEST(wait_timeoutWaits);
 264         CPPUNIT_TEST_SUITE_END();
 265     };
 266
 267     /** testing the method:
 268         sal_Bool check()
 269     */
 270     class check : public CppUnit::TestFixture
 271     {
 272     public:
 273         bool bRes, bRes1, bRes2;
 274
 275         void check_checkStates()
 276         {
 277             ::osl::Condition aCond;
 278
 279             aCond.reset();
 280             bRes = aCond.check();
 281             aCond.set();
 282             bRes1 = aCond.check();
 283
 284             CPPUNIT_ASSERT_MESSAGE("#test comment#: check the condition states.",
 285                                    !bRes );
 286             CPPUNIT_ASSERT_MESSAGE("#test comment#: check the condition states.",
 287                                    bRes1 );
 288         }
 289
 290         void check_threadedCheckStates( )
 291         {
 292             ::osl::Condition aCond;
 293             aCond.reset();
 294
 295             ConditionThread myThread(aCond, thread_type_set);
 296             myThread.create();
 297             myThread.join();
 298             bRes = aCond.check();
 299
 300             ConditionThread myThread1(aCond, thread_type_reset);
 301             myThread1.create();
 302             myThread1.join();
 303             bRes1 = aCond.check();
 304
 305             CPPUNIT_ASSERT_MESSAGE("#test comment#: use threads to set/reset Condition and check it in main routine.",
 306                                    bRes );
 307             CPPUNIT_ASSERT_MESSAGE("#test comment#: use threads to set/reset Condition and check it in main routine.",
 308                                    !bRes1 );
 309         }
 310
 311         CPPUNIT_TEST_SUITE(check);
 312         CPPUNIT_TEST(check_checkStates);
 313         CPPUNIT_TEST(check_threadedCheckStates);
 314         CPPUNIT_TEST_SUITE_END();
 315     };
 316
 317     CPPUNIT_TEST_SUITE_REGISTRATION(osl_Condition::ctors);
 318     CPPUNIT_TEST_SUITE_REGISTRATION(osl_Condition::set);
 319     CPPUNIT_TEST_SUITE_REGISTRATION(osl_Condition::reset);
 320     CPPUNIT_TEST_SUITE_REGISTRATION(osl_Condition::wait);
 321     CPPUNIT_TEST_SUITE_REGISTRATION(osl_Condition::check);
 322
 323 } // namespace osl_Condition
 324
 325 CPPUNIT_PLUGIN_IMPLEMENT();
 326
 327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */