Line data    Source code

       1             : /******************************************************************************
       2             :  * Project:  GDAL Core
       3             :  * Purpose:  Test getting driver metadata concurrently from multiple threads.
       4             :  * Author:   Even Rouault <even dot rouault at spatialys.com>
       5             :  *
       6             :  ******************************************************************************
       7             :  * Copyright (c) 2025, Even Rouault <even dot rouault at spatialys.com>
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : 
      12             : #include "gdal_priv.h"
      13             : 
      14             : #include "gtest_include.h"
      15             : 
      16             : #include <thread>
      17             : 
      18             : namespace
      19             : {
      20             : 
      21         200 : static bool test(int mainIter)
      22             : {
      23         200 :     bool ret = true;
      24         200 :     GDALAllRegister();
      25             : 
      26         400 :     const char *pszItem = (mainIter % 2) == 0
      27         200 :                               ? GDAL_DMD_CREATIONOPTIONLIST
      28             :                               : GDAL_DS_LAYER_CREATIONOPTIONLIST;
      29             : 
      30         200 :     auto poDM = GetGDALDriverManager();
      31         200 :     const int nDriverCount = poDM->GetDriverCount();
      32       44200 :     for (int iDrv = 0; iDrv < nDriverCount; ++iDrv)
      33             :     {
      34       44000 :         auto poDriver = poDM->GetDriver(iDrv);
      35       44000 :         if (poDriver->pfnCreate || poDriver->pfnCreateCopy)
      36             :         {
      37       32800 :             std::vector<std::thread> threads;
      38       32800 :             std::vector<std::string> tabretval(4);
      39       82000 :             for (size_t i = 0; i < tabretval.size(); ++i)
      40             :             {
      41       65600 :                 std::string &retval = tabretval[i];
      42             :                 threads.emplace_back(
      43      167161 :                     [pszItem, i, poDriver, &retval]()
      44             :                     {
      45             :                         const char *pszStr;
      46       65585 :                         if ((i % 2) == 0)
      47             :                         {
      48       32799 :                             pszStr = poDriver->GetMetadataItem(pszItem);
      49             :                         }
      50             :                         else
      51             :                         {
      52       32786 :                             pszStr = CSLFetchNameValue(poDriver->GetMetadata(),
      53             :                                                        pszItem);
      54             :                         }
      55       65590 :                         if (pszStr)
      56       35991 :                             retval = pszStr;
      57       65600 :                     });
      58             :             }
      59       82000 :             for (size_t i = 0; i < tabretval.size(); ++i)
      60             :             {
      61       65600 :                 threads[i].join();
      62       65600 :                 if (i > 0 && tabretval[i] != tabretval[0])
      63             :                 {
      64           0 :                     fprintf(stderr, "%s\n", poDriver->GetDescription());
      65           0 :                     ret = false;
      66             :                 }
      67             :             }
      68             :         }
      69             :     }
      70             : 
      71         200 :     GDALDestroyDriverManager();
      72         200 :     return ret;
      73             : }
      74             : 
      75           4 : TEST(Test, test)
      76             : {
      77         201 :     for (int i = 0; i < 200; ++i)
      78             :     {
      79         200 :         ASSERT_TRUE(test(i));
      80             :     }
      81             : }
      82             : 
      83             : }  // namespace