sal/qa/rtl/alloc/rtl_alloc.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 <rtl/alloc.h>
  21 #include <rtl/ustrbuf.hxx>
  22 #include <sal/types.h>
  23 #include <cppunit/TestFixture.h>
  24 #include <cppunit/extensions/HelperMacros.h>
  25 #include <cppunit/plugin/TestPlugIn.h>
  26
  27 #include "../../../rtl/strimp.hxx"
  28
  29 namespace rtl_alloc
  30 {
  31
  32     // small memory check routine, which return false, if there is a problem
  33
  34     static bool checkMemory(const char* _pMemory, sal_uInt32 _nSize, char _n)
  35     {
  36         bool bOk = true;
  37
  38         for (sal_uInt32 i=0;i<_nSize;i++)
  39         {
  40             if (_pMemory[i] != _n)
  41             {
  42                 bOk = false;
  43             }
  44         }
  45         return bOk;
  46     }
  47
  48 class Memory : public CppUnit::TestFixture
  49 {
  50     // for normal alloc functions
  51     char       *m_pMemory;
  52     static const sal_uInt32  m_nSizeOfMemory = 1024;
  53
  54 public:
  55     Memory()
  56         : m_pMemory(nullptr)
  57     {
  58     }
  59
  60     // initialise your test code values here.
  61     void setUp() override
  62     {
  63         m_pMemory = static_cast<char*>(rtl_allocateMemory( m_nSizeOfMemory ));
  64     }
  65
  66     void tearDown() override
  67     {
  68         rtl_freeMemory(m_pMemory);
  69         m_pMemory = nullptr;
  70     }
  71
  72     void rtl_allocateMemory_001()
  73     {
  74         CPPUNIT_ASSERT_MESSAGE( "Can get zero memory.", m_pMemory != nullptr);
  75         memset(m_pMemory, 1, m_nSizeOfMemory);
  76         CPPUNIT_ASSERT_MESSAGE( "memory contains wrong value.", checkMemory(m_pMemory, m_nSizeOfMemory, 1));
  77     }
  78
  79     void rtl_reallocateMemory_001()
  80     {
  81         sal_uInt32 nSize = 2 * 1024;
  82         m_pMemory = static_cast<char*>(rtl_reallocateMemory(m_pMemory, nSize));
  83
  84         CPPUNIT_ASSERT_MESSAGE( "Can reallocate memory.", m_pMemory != nullptr);
  85         memset(m_pMemory, 2, nSize);
  86         CPPUNIT_ASSERT_MESSAGE( "memory contains wrong value.", checkMemory(m_pMemory, nSize, 2));
  87     }
  88
  89     CPPUNIT_TEST_SUITE(Memory);
  90     CPPUNIT_TEST(rtl_allocateMemory_001);
  91     CPPUNIT_TEST(rtl_reallocateMemory_001);
  92     CPPUNIT_TEST_SUITE_END();
  93 }; // class test
  94
  95 class TestZeroMemory : public CppUnit::TestFixture
  96 {
  97     // for zero functions
  98     char       *m_pZeroMemory;
  99     static const sal_uInt32  m_nSizeOfZeroMemory = 50 * 1024 * 1024;
 100
 101 public:
 102     TestZeroMemory()
 103         : m_pZeroMemory(nullptr)
 104     {
 105     }
 106
 107     // initialise your test code values here.
 108     void setUp() override
 109     {
 110         m_pZeroMemory = static_cast<char*>(rtl_allocateZeroMemory( m_nSizeOfZeroMemory ));
 111     }
 112
 113     void tearDown() override
 114     {
 115         rtl_freeZeroMemory(m_pZeroMemory, m_nSizeOfZeroMemory);
 116         // LLA: no check possible, may GPF if there is something wrong.
 117         // CPPUNIT_ASSERT_MESSAGE( "Can get zero memory.", pZeroMemory != NULL);
 118     }
 119
 120     // insert your test code here.
 121
 122     void rtl_allocateZeroMemory_001()
 123     {
 124         CPPUNIT_ASSERT_MESSAGE( "Can get zero memory.", m_pZeroMemory != nullptr);
 125         CPPUNIT_ASSERT_MESSAGE( "memory contains wrong value.", checkMemory(m_pZeroMemory, m_nSizeOfZeroMemory, 0));
 126
 127         memset(m_pZeroMemory, 3, m_nSizeOfZeroMemory);
 128         CPPUNIT_ASSERT_MESSAGE( "memory contains wrong value.", checkMemory(m_pZeroMemory, m_nSizeOfZeroMemory, 3));
 129     }
 130
 131     CPPUNIT_TEST_SUITE(TestZeroMemory);
 132     CPPUNIT_TEST(rtl_allocateZeroMemory_001);
 133     CPPUNIT_TEST_SUITE_END();
 134 };
 135
 136 class TestPreinit : public CppUnit::TestFixture
 137 {
 138 public:
 139     TestPreinit()
 140     {
 141     }
 142
 143     // initialise your test code values here.
 144     void setUp() override
 145     {
 146     }
 147
 148     void tearDown() override
 149     {
 150     }
 151
 152     // insert your test code here.
 153
 154     void test()
 155     {
 156         const char sample[] = "Hello World";
 157         std::vector<OUString> aStrings;
 158
 159         rtl_alloc_preInit(true);
 160
 161         OUString aFoo("foo");
 162
 163         // fill some cache bits
 164         for (int iter = 0; iter < 4; iter++)
 165         {
 166             for (int i = 1; i < 4096; i += 8)
 167             {
 168                 OUStringBuffer aBuf(i);
 169                 aBuf.appendAscii(sample, (i/8) % (SAL_N_ELEMENTS(sample)-1));
 170                 OUString aStr = aBuf.makeStringAndClear();
 171                 aStrings.push_back(aStr);
 172             }
 173             // free some pieces to make holes
 174             for (size_t i = iter; i < aStrings.size(); i += 17)
 175                 aStrings[i] = aFoo;
 176         }
 177
 178         for (size_t i = 0; i < aStrings.size(); ++i)
 179         {
 180             CPPUNIT_ASSERT_MESSAGE( "not static before.", !(aStrings[i].pData->refCount & SAL_STRING_STATIC_FLAG) );
 181         }
 182
 183         // should static-ize all the strings.
 184         rtl_alloc_preInit(false);
 185
 186         for (size_t i = 0; i < aStrings.size(); ++i)
 187             CPPUNIT_ASSERT_MESSAGE( "static after.", (aStrings[i].pData->refCount & SAL_STRING_STATIC_FLAG) );
 188     }
 189
 190     void test2()
 191     {
 192         // should never happen but lets try it again.
 193         test();
 194     }
 195
 196     CPPUNIT_TEST_SUITE(TestPreinit);
 197     CPPUNIT_TEST(test);
 198     CPPUNIT_TEST(test2);
 199     CPPUNIT_TEST_SUITE_END();
 200 };
 201
 202 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_alloc::Memory);
 203 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_alloc::TestZeroMemory);
 204 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_alloc::TestPreinit);
 205 } // namespace rtl_alloc
 206
 207 CPPUNIT_PLUGIN_IMPLEMENT();
 208
 209 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */