sal/qa/rtl/doublelock/rtl_doublelocking.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 <sal/config.h>
  21
  22 #include <iostream>
  23
  24 #include <sal/types.h>
  25
  26 #include <osl/thread.hxx>
  27
  28 #include <rtl/instance.hxx>
  29 #include <rtl/ustring.hxx>
  30
  31 #include <cppunit/TestFixture.h>
  32 #include <cppunit/extensions/HelperMacros.h>
  33
  34 #ifdef _WIN32
  35 #if !defined WIN32_LEAN_AND_MEAN
  36 # define WIN32_LEAN_AND_MEAN
  37 #endif
  38 #include <windows.h>
  39 #endif
  40
  41 #define CONST_TEST_STRING "gregorian"
  42
  43 namespace {
  44 struct Gregorian : public rtl::StaticWithInit<OUString, Gregorian> {
  45     OUString operator () () {
  46         return u"" CONST_TEST_STRING ""_ustr;
  47     }
  48 };
  49
  50 /** Simple thread for testing Thread-create.
  51  * Just add 1 of value 0, and after running, result is 1.
  52  */
  53 class OGetThread : public osl::Thread
  54 {
  55     osl::Mutex m_mutex;
  56     sal_Int32 m_nOK;
  57     sal_Int32 m_nFails;
  58
  59     OUString m_sConstStr;
  60 public:
  61     OGetThread()
  62             :m_nOK(0),
  63              m_nFails(0),
  64              m_sConstStr(u"" CONST_TEST_STRING ""_ustr)
  65         {
  66         }
  67
  68     sal_Int32 getOK() { osl::MutexGuard g(m_mutex); return m_nOK; }
  69     sal_Int32 getFails() {osl::MutexGuard g(m_mutex); return m_nFails;}
  70
  71 protected:
  72
  73     /** guarded value which initialized 0
  74
  75         @see ThreadSafeValue
  76     */
  77     void SAL_CALL run() override
  78         {
  79             for (int i = 0; i != 5; ++i)
  80             {
  81                 OUString aStr = Gregorian::get();
  82                 if (aStr == m_sConstStr)
  83                 {
  84                     osl::MutexGuard g(m_mutex);
  85                     m_nOK++;
  86                 }
  87                 else
  88                 {
  89                     osl::MutexGuard g(m_mutex);
  90                     m_nFails++;
  91                 }
  92             }
  93         }
  94
  95 public:
  96
  97     virtual ~OGetThread() override
  98         {
  99             if (isRunning())
 100             {
 101                 printf("error: not terminated.\n");
 102             }
 103         }
 104 };
 105
 106 }
 107
 108 namespace rtl_DoubleLocking
 109 {
 110
 111 /** Test of the osl::Thread::create method
 112  */
 113
 114     class getValue : public CppUnit::TestFixture
 115     {
 116     public:
 117
 118         void getValue_001()
 119             {
 120                 OUString aStr = Gregorian::get();
 121
 122                 CPPUNIT_ASSERT_MESSAGE(
 123                     "Gregorian::get() failed, wrong value expected.",
 124                     !aStr.isEmpty()
 125                     );
 126             }
 127
 128         /** check 2 threads.
 129
 130             ALGORITHM:
 131             Here the function should show, that 2 different threads,
 132             which only increase a value, should run at the same time with same prio.
 133             The test fails, if the difference between the two values is more than 5%
 134             but IMHO this isn't a failure, it's only a feature of the OS.
 135         */
 136
 137         void getValue_002()
 138             {
 139                 // initial 5 threads with different priorities
 140                 OGetThread* pThread = new OGetThread();
 141                 OGetThread* p2Thread = new OGetThread();
 142
 143                 //Create them and start running at the same time
 144                 pThread->create();
 145                 p2Thread->create();
 146
 147                 pThread->join();
 148                 p2Thread->join();
 149
 150                 sal_Int32 nValueOK = pThread->getOK();
 151
 152                 sal_Int32 nValueOK2 = p2Thread->getOK();
 153
 154                 std::cout << "Value in Thread #1 is " << nValueOK << "\n";
 155                 std::cout << "Value in Thread #2 is " << nValueOK2 << "\n";
 156                 sal_Int32 nValueFails = pThread->getFails();
 157
 158                 sal_Int32 nValueFails2 = p2Thread->getFails();
 159
 160                 delete pThread;
 161                 delete p2Thread;
 162
 163                 CPPUNIT_ASSERT_EQUAL(sal_Int32(5), nValueOK);
 164                 CPPUNIT_ASSERT_EQUAL(sal_Int32(5), nValueOK2);
 165                 CPPUNIT_ASSERT_EQUAL(sal_Int32(0), nValueFails);
 166                 CPPUNIT_ASSERT_EQUAL(sal_Int32(0), nValueFails2);
 167             }
 168
 169         CPPUNIT_TEST_SUITE(getValue);
 170         CPPUNIT_TEST(getValue_001);
 171         CPPUNIT_TEST(getValue_002);
 172         CPPUNIT_TEST_SUITE_END();
 173     }; // class create
 174
 175     CPPUNIT_TEST_SUITE_REGISTRATION(rtl_DoubleLocking::getValue);
 176 } // namespace rtl_DoubleLocking
 177
 178 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */