LCOV - code coverage report
Current view: top level - autotest/cpp - test_cpl.cpp (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 2976 3051 97.5 %
Date: 2025-10-21 22:35:35 Functions: 451 456 98.9 %

          Line data    Source code
       1             : ///////////////////////////////////////////////////////////////////////////////
       2             : //
       3             : // Project:  C++ Test Suite for GDAL/OGR
       4             : // Purpose:  Test general CPL features.
       5             : // Author:   Mateusz Loskot <mateusz@loskot.net>
       6             : //
       7             : ///////////////////////////////////////////////////////////////////////////////
       8             : // Copyright (c) 2006, Mateusz Loskot <mateusz@loskot.net>
       9             : // Copyright (c) 2008-2012, Even Rouault <even dot rouault at spatialys.com>
      10             : // Copyright (c) 2017, Dmitry Baryshnikov <polimax@mail.ru>
      11             : // Copyright (c) 2017, NextGIS <info@nextgis.com>
      12             : /*
      13             :  * SPDX-License-Identifier: MIT
      14             :  ****************************************************************************/
      15             : 
      16             : #ifndef GDAL_COMPILATION
      17             : #define GDAL_COMPILATION
      18             : #endif
      19             : 
      20             : #include "gdal_unit_test.h"
      21             : 
      22             : #include "cpl_compressor.h"
      23             : #include "cpl_error.h"
      24             : #include "cpl_float.h"
      25             : #include "cpl_hash_set.h"
      26             : #include "cpl_levenshtein.h"
      27             : #include "cpl_list.h"
      28             : #include "cpl_mask.h"
      29             : #include "cpl_sha256.h"
      30             : #include "cpl_string.h"
      31             : #include "cpl_safemaths.hpp"
      32             : #include "cpl_time.h"
      33             : #include "cpl_json.h"
      34             : #include "cpl_json_streaming_parser.h"
      35             : #include "cpl_json_streaming_writer.h"
      36             : #include "cpl_mem_cache.h"
      37             : #include "cpl_http.h"
      38             : #include "cpl_auto_close.h"
      39             : #include "cpl_minixml.h"
      40             : #include "cpl_quad_tree.h"
      41             : #include "cpl_spawn.h"
      42             : #include "cpl_worker_thread_pool.h"
      43             : #include "cpl_vsi_virtual.h"
      44             : #include "cpl_threadsafe_queue.hpp"
      45             : 
      46             : #include <atomic>
      47             : #include <cmath>
      48             : #include <limits>
      49             : #include <fstream>
      50             : #include <string>
      51             : 
      52             : #if !defined(_WIN32)
      53             : #include <unistd.h>
      54             : #endif
      55             : 
      56             : #include "test_data.h"
      57             : 
      58             : #include "gtest_include.h"
      59             : 
      60             : static bool gbGotError = false;
      61             : 
      62           2 : static void CPL_STDCALL myErrorHandler(CPLErr, CPLErrorNum, const char *)
      63             : {
      64           2 :     gbGotError = true;
      65           2 : }
      66             : 
      67             : namespace
      68             : {
      69             : 
      70             : // Common fixture with test data
      71             : struct test_cpl : public ::testing::Test
      72             : {
      73             :     std::string data_;
      74             : 
      75          98 :     test_cpl()
      76          98 :     {
      77             :         // Compose data path for test group
      78          98 :         data_ = tut::common::data_basedir;
      79          98 :     }
      80             : 
      81          98 :     void SetUp() override
      82             :     {
      83          98 :         CPLSetConfigOptions(nullptr);
      84          98 :         CPLSetThreadLocalConfigOptions(nullptr);
      85          98 :     }
      86             : };
      87             : 
      88             : // Test cpl_list API
      89           4 : TEST_F(test_cpl, CPLList)
      90             : {
      91             :     CPLList *list;
      92             : 
      93           1 :     list = CPLListInsert(nullptr, (void *)nullptr, 0);
      94           1 :     EXPECT_TRUE(CPLListCount(list) == 1);
      95           1 :     list = CPLListRemove(list, 2);
      96           1 :     EXPECT_TRUE(CPLListCount(list) == 1);
      97           1 :     list = CPLListRemove(list, 1);
      98           1 :     EXPECT_TRUE(CPLListCount(list) == 1);
      99           1 :     list = CPLListRemove(list, 0);
     100           1 :     EXPECT_TRUE(CPLListCount(list) == 0);
     101           1 :     list = nullptr;
     102             : 
     103           1 :     list = CPLListInsert(nullptr, (void *)nullptr, 2);
     104           1 :     EXPECT_TRUE(CPLListCount(list) == 3);
     105           1 :     list = CPLListRemove(list, 2);
     106           1 :     EXPECT_TRUE(CPLListCount(list) == 2);
     107           1 :     list = CPLListRemove(list, 1);
     108           1 :     EXPECT_TRUE(CPLListCount(list) == 1);
     109           1 :     list = CPLListRemove(list, 0);
     110           1 :     EXPECT_TRUE(CPLListCount(list) == 0);
     111           1 :     list = nullptr;
     112             : 
     113           1 :     list = CPLListAppend(list, (void *)1);
     114           1 :     EXPECT_TRUE(CPLListGet(list, 0) == list);
     115           1 :     EXPECT_TRUE(CPLListGet(list, 1) == nullptr);
     116           1 :     list = CPLListAppend(list, (void *)2);
     117           1 :     list = CPLListInsert(list, (void *)3, 2);
     118           1 :     EXPECT_TRUE(CPLListCount(list) == 3);
     119           1 :     CPLListDestroy(list);
     120           1 :     list = nullptr;
     121             : 
     122           1 :     list = CPLListAppend(list, (void *)1);
     123           1 :     list = CPLListAppend(list, (void *)2);
     124           1 :     list = CPLListInsert(list, (void *)4, 3);
     125           1 :     CPLListGet(list, 2)->pData = (void *)3;
     126           1 :     EXPECT_TRUE(CPLListCount(list) == 4);
     127           1 :     EXPECT_TRUE(CPLListGet(list, 0)->pData == (void *)1);
     128           1 :     EXPECT_TRUE(CPLListGet(list, 1)->pData == (void *)2);
     129           1 :     EXPECT_TRUE(CPLListGet(list, 2)->pData == (void *)3);
     130           1 :     EXPECT_TRUE(CPLListGet(list, 3)->pData == (void *)4);
     131           1 :     CPLListDestroy(list);
     132           1 :     list = nullptr;
     133             : 
     134           1 :     list = CPLListInsert(list, (void *)4, 1);
     135           1 :     CPLListGet(list, 0)->pData = (void *)2;
     136           1 :     list = CPLListInsert(list, (void *)1, 0);
     137           1 :     list = CPLListInsert(list, (void *)3, 2);
     138           1 :     EXPECT_TRUE(CPLListCount(list) == 4);
     139           1 :     EXPECT_TRUE(CPLListGet(list, 0)->pData == (void *)1);
     140           1 :     EXPECT_TRUE(CPLListGet(list, 1)->pData == (void *)2);
     141           1 :     EXPECT_TRUE(CPLListGet(list, 2)->pData == (void *)3);
     142           1 :     EXPECT_TRUE(CPLListGet(list, 3)->pData == (void *)4);
     143           1 :     list = CPLListRemove(list, 1);
     144           1 :     list = CPLListRemove(list, 1);
     145           1 :     list = CPLListRemove(list, 0);
     146           1 :     list = CPLListRemove(list, 0);
     147           1 :     EXPECT_TRUE(list == nullptr);
     148           1 : }
     149             : 
     150             : typedef struct
     151             : {
     152             :     const char *testString;
     153             :     CPLValueType expectedResult;
     154             : } TestStringStruct;
     155             : 
     156             : // Test CPLGetValueType
     157           4 : TEST_F(test_cpl, CPLGetValueType)
     158             : {
     159           1 :     TestStringStruct asTestStrings[] = {
     160             :         {"+25.e+3", CPL_VALUE_REAL},   {"-25.e-3", CPL_VALUE_REAL},
     161             :         {"25.e3", CPL_VALUE_REAL},     {"25e3", CPL_VALUE_REAL},
     162             :         {" 25e3 ", CPL_VALUE_REAL},    {".1e3", CPL_VALUE_REAL},
     163             : 
     164             :         {"25", CPL_VALUE_INTEGER},     {"-25", CPL_VALUE_INTEGER},
     165             :         {"+25", CPL_VALUE_INTEGER},
     166             : 
     167             :         {"25e 3", CPL_VALUE_STRING},   {"25e.3", CPL_VALUE_STRING},
     168             :         {"-2-5e3", CPL_VALUE_STRING},  {"2-5e3", CPL_VALUE_STRING},
     169             :         {"25.25.3", CPL_VALUE_STRING}, {"25e25e3", CPL_VALUE_STRING},
     170             :         {"25e2500", CPL_VALUE_STRING}, /* #6128 */
     171             : 
     172             :         {"d1", CPL_VALUE_STRING}, /* #6305 */
     173             : 
     174             :         {"01", CPL_VALUE_STRING},      {"0.1", CPL_VALUE_REAL},
     175             :         {"0", CPL_VALUE_INTEGER},
     176             :     };
     177             : 
     178          21 :     for (const auto &sText : asTestStrings)
     179             :     {
     180          20 :         EXPECT_EQ(CPLGetValueType(sText.testString), sText.expectedResult)
     181           0 :             << sText.testString;
     182             :     }
     183           1 : }
     184             : 
     185             : // Test cpl_hash_set API
     186           4 : TEST_F(test_cpl, CPLHashSet)
     187             : {
     188             :     CPLHashSet *set =
     189           1 :         CPLHashSetNew(CPLHashSetHashStr, CPLHashSetEqualStr, CPLFree);
     190           1 :     EXPECT_TRUE(CPLHashSetInsert(set, CPLStrdup("hello")) == TRUE);
     191           1 :     EXPECT_TRUE(CPLHashSetInsert(set, CPLStrdup("good morning")) == TRUE);
     192           1 :     EXPECT_TRUE(CPLHashSetInsert(set, CPLStrdup("bye bye")) == TRUE);
     193           1 :     EXPECT_TRUE(CPLHashSetSize(set) == 3);
     194           1 :     EXPECT_TRUE(CPLHashSetInsert(set, CPLStrdup("bye bye")) == FALSE);
     195           1 :     EXPECT_TRUE(CPLHashSetSize(set) == 3);
     196           1 :     EXPECT_TRUE(CPLHashSetRemove(set, "bye bye") == TRUE);
     197           1 :     EXPECT_TRUE(CPLHashSetSize(set) == 2);
     198           1 :     EXPECT_TRUE(CPLHashSetRemove(set, "good afternoon") == FALSE);
     199           1 :     EXPECT_TRUE(CPLHashSetSize(set) == 2);
     200           1 :     CPLHashSetDestroy(set);
     201           1 : }
     202             : 
     203        1000 : static int sumValues(void *elt, void *user_data)
     204             : {
     205        1000 :     int *pnSum = (int *)user_data;
     206        1000 :     *pnSum += *(int *)elt;
     207        1000 :     return TRUE;
     208             : }
     209             : 
     210             : // Test cpl_hash_set API
     211           4 : TEST_F(test_cpl, CPLHashSet2)
     212             : {
     213           1 :     const int HASH_SET_SIZE = 1000;
     214             : 
     215             :     int data[HASH_SET_SIZE];
     216        1001 :     for (int i = 0; i < HASH_SET_SIZE; ++i)
     217             :     {
     218        1000 :         data[i] = i;
     219             :     }
     220             : 
     221           1 :     CPLHashSet *set = CPLHashSetNew(nullptr, nullptr, nullptr);
     222        1001 :     for (int i = 0; i < HASH_SET_SIZE; i++)
     223             :     {
     224        1000 :         EXPECT_TRUE(CPLHashSetInsert(set, (void *)&data[i]) == TRUE);
     225             :     }
     226           1 :     EXPECT_EQ(CPLHashSetSize(set), HASH_SET_SIZE);
     227             : 
     228        1001 :     for (int i = 0; i < HASH_SET_SIZE; i++)
     229             :     {
     230        1000 :         EXPECT_TRUE(CPLHashSetInsert(set, (void *)&data[i]) == FALSE);
     231             :     }
     232           1 :     EXPECT_EQ(CPLHashSetSize(set), HASH_SET_SIZE);
     233             : 
     234        1001 :     for (int i = 0; i < HASH_SET_SIZE; i++)
     235             :     {
     236        1000 :         EXPECT_TRUE(CPLHashSetLookup(set, (const void *)&data[i]) ==
     237             :                     (const void *)&data[i]);
     238             :     }
     239             : 
     240           1 :     int sum = 0;
     241           1 :     CPLHashSetForeach(set, sumValues, &sum);
     242           1 :     EXPECT_EQ(sum, (HASH_SET_SIZE - 1) * HASH_SET_SIZE / 2);
     243             : 
     244        1001 :     for (int i = 0; i < HASH_SET_SIZE; i++)
     245             :     {
     246        1000 :         EXPECT_TRUE(CPLHashSetRemove(set, (void *)&data[i]) == TRUE);
     247             :     }
     248           1 :     EXPECT_EQ(CPLHashSetSize(set), 0);
     249             : 
     250           1 :     CPLHashSetDestroy(set);
     251           1 : }
     252             : 
     253             : // Test cpl_string API
     254           4 : TEST_F(test_cpl, CSLTokenizeString2)
     255             : {
     256             :     {
     257             :         CPLStringList aosStringList(
     258           1 :             CSLTokenizeString2("one two three", " ", 0));
     259           1 :         ASSERT_EQ(aosStringList.size(), 3);
     260           1 :         EXPECT_STREQ(aosStringList[0], "one");
     261           1 :         EXPECT_STREQ(aosStringList[1], "two");
     262           1 :         EXPECT_STREQ(aosStringList[2], "three");
     263             : 
     264             :         // Test range-based for loop
     265           1 :         int i = 0;
     266           4 :         for (const char *pszVal : aosStringList)
     267             :         {
     268           3 :             EXPECT_STREQ(pszVal, aosStringList[i]);
     269           3 :             ++i;
     270             :         }
     271           1 :         EXPECT_EQ(i, 3);
     272             :     }
     273             :     {
     274           2 :         CPLStringList aosStringList;
     275             :         // Test range-based for loop on empty list
     276           1 :         int i = 0;
     277           1 :         for (const char *pszVal : aosStringList)
     278             :         {
     279           0 :             EXPECT_EQ(pszVal, nullptr);  // should not reach that point...
     280           0 :             ++i;
     281             :         }
     282           1 :         EXPECT_EQ(i, 0);
     283             :     }
     284             :     {
     285             :         CPLStringList aosStringList(
     286           1 :             CSLTokenizeString2("one two, three;four,five; six", " ;,", 0));
     287           1 :         ASSERT_EQ(aosStringList.size(), 6);
     288           1 :         EXPECT_STREQ(aosStringList[0], "one");
     289           1 :         EXPECT_STREQ(aosStringList[1], "two");
     290           1 :         EXPECT_STREQ(aosStringList[2], "three");
     291           1 :         EXPECT_STREQ(aosStringList[3], "four");
     292           1 :         EXPECT_STREQ(aosStringList[4], "five");
     293           1 :         EXPECT_STREQ(aosStringList[5], "six");
     294             :     }
     295             : 
     296             :     {
     297             :         CPLStringList aosStringList(CSLTokenizeString2(
     298           1 :             "one two,,,five,six", " ,", CSLT_ALLOWEMPTYTOKENS));
     299           1 :         ASSERT_EQ(aosStringList.size(), 6);
     300           1 :         EXPECT_STREQ(aosStringList[0], "one");
     301           1 :         EXPECT_STREQ(aosStringList[1], "two");
     302           1 :         EXPECT_STREQ(aosStringList[2], "");
     303           1 :         EXPECT_STREQ(aosStringList[3], "");
     304           1 :         EXPECT_STREQ(aosStringList[4], "five");
     305           1 :         EXPECT_STREQ(aosStringList[5], "six");
     306             :     }
     307             : 
     308             :     {
     309             :         CPLStringList aosStringList(CSLTokenizeString2(
     310           1 :             "one two,\"three,four ,\",five,six", " ,", CSLT_HONOURSTRINGS));
     311           1 :         ASSERT_EQ(aosStringList.size(), 5);
     312           1 :         EXPECT_STREQ(aosStringList[0], "one");
     313           1 :         EXPECT_STREQ(aosStringList[1], "two");
     314           1 :         EXPECT_STREQ(aosStringList[2], "three,four ,");
     315           1 :         EXPECT_STREQ(aosStringList[3], "five");
     316           1 :         EXPECT_STREQ(aosStringList[4], "six");
     317             :     }
     318             : 
     319             :     {
     320             :         CPLStringList aosStringList(CSLTokenizeString2(
     321           1 :             "one two,\"three,four ,\",five,six", " ,", CSLT_PRESERVEQUOTES));
     322           1 :         ASSERT_EQ(aosStringList.size(), 7);
     323           1 :         EXPECT_STREQ(aosStringList[0], "one");
     324           1 :         EXPECT_STREQ(aosStringList[1], "two");
     325           1 :         EXPECT_STREQ(aosStringList[2], "\"three");
     326           1 :         EXPECT_STREQ(aosStringList[3], "four");
     327           1 :         EXPECT_STREQ(aosStringList[4], "\"");
     328           1 :         EXPECT_STREQ(aosStringList[5], "five");
     329           1 :         EXPECT_STREQ(aosStringList[6], "six");
     330             :     }
     331             : 
     332             :     {
     333             :         CPLStringList aosStringList(
     334             :             CSLTokenizeString2("one two,\"three,four ,\",five,six", " ,",
     335           1 :                                CSLT_HONOURSTRINGS | CSLT_PRESERVEQUOTES));
     336           1 :         ASSERT_EQ(aosStringList.size(), 5);
     337           1 :         EXPECT_STREQ(aosStringList[0], "one");
     338           1 :         EXPECT_STREQ(aosStringList[1], "two");
     339           1 :         EXPECT_STREQ(aosStringList[2], "\"three,four ,\"");
     340           1 :         EXPECT_STREQ(aosStringList[3], "five");
     341           1 :         EXPECT_STREQ(aosStringList[4], "six");
     342             :     }
     343             : 
     344             :     {
     345             :         CPLStringList aosStringList(
     346             :             CSLTokenizeString2("one \\two,\"three,\\four ,\",five,six", " ,",
     347           1 :                                CSLT_PRESERVEESCAPES));
     348           1 :         ASSERT_EQ(aosStringList.size(), 7);
     349           1 :         EXPECT_STREQ(aosStringList[0], "one");
     350           1 :         EXPECT_STREQ(aosStringList[1], "\\two");
     351           1 :         EXPECT_STREQ(aosStringList[2], "\"three");
     352           1 :         EXPECT_STREQ(aosStringList[3], "\\four");
     353           1 :         EXPECT_STREQ(aosStringList[4], "\"");
     354           1 :         EXPECT_STREQ(aosStringList[5], "five");
     355           1 :         EXPECT_STREQ(aosStringList[6], "six");
     356             :     }
     357             : 
     358             :     {
     359             :         CPLStringList aosStringList(
     360             :             CSLTokenizeString2("one \\two,\"three,\\four ,\",five,six", " ,",
     361           1 :                                CSLT_PRESERVEQUOTES | CSLT_PRESERVEESCAPES));
     362           1 :         ASSERT_EQ(aosStringList.size(), 7);
     363           1 :         EXPECT_STREQ(aosStringList[0], "one");
     364           1 :         EXPECT_STREQ(aosStringList[1], "\\two");
     365           1 :         EXPECT_STREQ(aosStringList[2], "\"three");
     366           1 :         EXPECT_STREQ(aosStringList[3], "\\four");
     367           1 :         EXPECT_STREQ(aosStringList[4], "\"");
     368           1 :         EXPECT_STREQ(aosStringList[5], "five");
     369           1 :         EXPECT_STREQ(aosStringList[6], "six");
     370             :     }
     371             : 
     372             :     {
     373             :         CPLStringList aosStringList(
     374           1 :             CSLTokenizeString2("one ,two, three, four ,five  ", ",", 0));
     375           1 :         ASSERT_EQ(aosStringList.size(), 5);
     376           1 :         EXPECT_STREQ(aosStringList[0], "one ");
     377           1 :         EXPECT_STREQ(aosStringList[1], "two");
     378           1 :         EXPECT_STREQ(aosStringList[2], " three");
     379           1 :         EXPECT_STREQ(aosStringList[3], " four ");
     380           1 :         EXPECT_STREQ(aosStringList[4], "five  ");
     381             :     }
     382             : 
     383             :     {
     384             :         CPLStringList aosStringList(CSLTokenizeString2(
     385           1 :             "one ,two, three, four ,five  ", ",", CSLT_STRIPLEADSPACES));
     386           1 :         ASSERT_EQ(aosStringList.size(), 5);
     387           1 :         EXPECT_STREQ(aosStringList[0], "one ");
     388           1 :         EXPECT_STREQ(aosStringList[1], "two");
     389           1 :         EXPECT_STREQ(aosStringList[2], "three");
     390           1 :         EXPECT_STREQ(aosStringList[3], "four ");
     391           1 :         EXPECT_STREQ(aosStringList[4], "five  ");
     392             :     }
     393             : 
     394             :     {
     395             :         CPLStringList aosStringList(CSLTokenizeString2(
     396           1 :             "one ,two, three, four ,five  ", ",", CSLT_STRIPENDSPACES));
     397           1 :         ASSERT_EQ(aosStringList.size(), 5);
     398           1 :         EXPECT_STREQ(aosStringList[0], "one");
     399           1 :         EXPECT_STREQ(aosStringList[1], "two");
     400           1 :         EXPECT_STREQ(aosStringList[2], " three");
     401           1 :         EXPECT_STREQ(aosStringList[3], " four");
     402           1 :         EXPECT_STREQ(aosStringList[4], "five");
     403             :     }
     404             : 
     405             :     {
     406             :         CPLStringList aosStringList(
     407             :             CSLTokenizeString2("one ,two, three, four ,five  ", ",",
     408           1 :                                CSLT_STRIPLEADSPACES | CSLT_STRIPENDSPACES));
     409           1 :         ASSERT_EQ(aosStringList.size(), 5);
     410           1 :         EXPECT_STREQ(aosStringList[0], "one");
     411           1 :         EXPECT_STREQ(aosStringList[1], "two");
     412           1 :         EXPECT_STREQ(aosStringList[2], "three");
     413           1 :         EXPECT_STREQ(aosStringList[3], "four");
     414           1 :         EXPECT_STREQ(aosStringList[4], "five");
     415             :     }
     416             : 
     417             :     {
     418           5 :         const std::vector<std::string> oVector{"a", "bc"};
     419             :         // Test CPLStringList(const std::vector<std::string>&) constructor
     420           1 :         const CPLStringList aosList(oVector);
     421           1 :         ASSERT_EQ(aosList.size(), 2);
     422           1 :         EXPECT_STREQ(aosList[0], "a");
     423           1 :         EXPECT_STREQ(aosList[1], "bc");
     424           1 :         EXPECT_EQ(aosList[2], nullptr);
     425             : 
     426             :         // Test CPLStringList::operator std::vector<std::string>(void) const
     427           2 :         const std::vector<std::string> oVector2(aosList);
     428           1 :         EXPECT_EQ(oVector, oVector2);
     429             : 
     430           2 :         EXPECT_EQ(oVector, cpl::ToVector(aosList.List()));
     431             :     }
     432             : 
     433             :     {
     434           2 :         const CPLStringList aosList(std::vector<std::string>{});
     435           1 :         EXPECT_EQ(aosList.List(), nullptr);
     436             :     }
     437             : 
     438             :     {
     439             :         // Test CPLStringList(std::initializer_list<const char*>) constructor
     440           1 :         const CPLStringList aosList{"a", "bc"};
     441           1 :         ASSERT_EQ(aosList.size(), 2);
     442           1 :         EXPECT_STREQ(aosList[0], "a");
     443           1 :         EXPECT_STREQ(aosList[1], "bc");
     444           1 :         EXPECT_EQ(aosList[2], nullptr);
     445             : 
     446             :         // Test cpl::Iterate(CSLConstList)
     447           1 :         CSLConstList papszList = aosList.List();
     448           1 :         CPLStringList aosList2;
     449           3 :         for (const char *pszStr : cpl::Iterate(papszList))
     450             :         {
     451           2 :             aosList2.AddString(pszStr);
     452             :         }
     453           1 :         ASSERT_EQ(aosList2.size(), 2);
     454           1 :         EXPECT_STREQ(aosList2[0], "a");
     455           1 :         EXPECT_STREQ(aosList2[1], "bc");
     456           1 :         EXPECT_EQ(aosList2[2], nullptr);
     457             :     }
     458             : 
     459             :     {
     460             :         // Test cpl::Iterate() on a null list
     461           1 :         CSLConstList papszList = nullptr;
     462           1 :         auto oIteratorWrapper = cpl::Iterate(papszList);
     463           1 :         EXPECT_TRUE(oIteratorWrapper.begin() == oIteratorWrapper.end());
     464             :     }
     465             : 
     466             :     {
     467             :         // Test cpl::IterateNameValue()
     468           1 :         const CPLStringList aosList{"foo=bar", "illegal", "bar=baz"};
     469           1 :         CSLConstList papszList = aosList.List();
     470           1 :         std::map<std::string, std::string> oMap;
     471           3 :         for (const auto &[name, value] : cpl::IterateNameValue(papszList))
     472             :         {
     473           2 :             oMap[name] = value;
     474             :         }
     475           1 :         ASSERT_EQ(oMap.size(), 2U);
     476           2 :         EXPECT_EQ(oMap["foo"], "bar");
     477           2 :         EXPECT_EQ(oMap["bar"], "baz");
     478             :     }
     479             : 
     480             :     {
     481             :         // Test cpl::IterateNameValue() on a list with only invalid values
     482           2 :         const CPLStringList aosList{"illegal"};
     483           1 :         CSLConstList papszList = aosList.List();
     484           1 :         auto oIteratorWrapper = cpl::IterateNameValue(papszList);
     485           1 :         EXPECT_TRUE(oIteratorWrapper.begin() == oIteratorWrapper.end());
     486             :     }
     487             : 
     488             :     {
     489             :         // Test cpl::IterateNameValue() on a null list
     490           1 :         CSLConstList papszList = nullptr;
     491           1 :         auto oIteratorWrapper = cpl::IterateNameValue(papszList);
     492           1 :         EXPECT_TRUE(oIteratorWrapper.begin() == oIteratorWrapper.end());
     493             :     }
     494             : }
     495             : 
     496             : typedef struct
     497             : {
     498             :     char szEncoding[24];
     499             :     char szString[1024 - 24];
     500             : } TestRecodeStruct;
     501             : 
     502             : // Test cpl_recode API
     503           4 : TEST_F(test_cpl, CPLRecode)
     504             : {
     505             :     /*
     506             :      * NOTE: This test will generally fail if iconv() is not
     507             :      *       linked in.
     508             :      *
     509             :      * CPLRecode() will be tested using the test file containing
     510             :      * a list of strings of the same text in different encoding. The
     511             :      * string is non-ASCII to avoid trivial transformations. Test file
     512             :      * has a simple binary format: a table of records, each record
     513             :      * is 1024 bytes long. The first 24 bytes of each record contain
     514             :      * encoding name (ASCII, zero padded), the last 1000 bytes contain
     515             :      * encoded string, zero padded.
     516             :      *
     517             :      * NOTE 1: We can't use a test file in human readable text format
     518             :      *         here because of multiple different encodings including
     519             :      *         multibyte ones.
     520             :      *
     521             :      * The test file could be generated with the following simple shell
     522             :      * script:
     523             :      *
     524             :      * #!/bin/sh
     525             :      *
     526             :      * # List of encodings to convert the test string into
     527             :      * ENCODINGS="UTF-8 CP1251 KOI8-R UCS-2 UCS-2BE UCS-2LE UCS-4 UCS-4BE
     528             :      * UCS-4LE UTF-16 UTF-32" # The test string itself in UTF-8 encoding. # This
     529             :      * means "Improving GDAL internationalization." in Russian.
     530             :      * TESTSTRING="\u0423\u043b\u0443\u0447\u0448\u0430\u0435\u043c
     531             :      * \u0438\u043d\u0442\u0435\u0440\u043d\u0430\u0446\u0438\u043e\u043d\u0430\u043b\u0438\u0437\u0430\u0446\u0438\u044e
     532             :      * GDAL."
     533             :      *
     534             :      * RECORDSIZE=1024
     535             :      * ENCSIZE=24
     536             :      *
     537             :      * i=0
     538             :      * for enc in ${ENCODINGS}; do
     539             :      *  env printf "${enc}" | dd ibs=${RECORDSIZE} conv=sync obs=1
     540             :      * seek=$((${RECORDSIZE}*${i})) of="recode-rus.dat" status=noxfer env printf
     541             :      * "${TESTSTRING}" | iconv -t ${enc} | dd ibs=${RECORDSIZE} conv=sync obs=1
     542             :      * seek=$((${RECORDSIZE}*${i}+${ENCSIZE})) of="recode-rus.dat" status=noxfer
     543             :      *  i=$((i+1))
     544             :      * done
     545             :      *
     546             :      * NOTE 2: The test string is encoded with the special format
     547             :      *         "\uXXXX" sequences, so we able to paste it here.
     548             :      *
     549             :      * NOTE 3: We need a printf utility from the coreutils because of
     550             :      *         that. "env printf" should work avoiding the shell
     551             :      *         built-in.
     552             :      *
     553             :      * NOTE 4: "iconv" utility without the "-f" option will work with
     554             :      *         encoding read from the current locale.
     555             :      *
     556             :      *  TODO: 1. Add more encodings maybe more test files.
     557             :      *        2. Add test for CPLRecodeFromWChar()/CPLRecodeToWChar().
     558             :      *        3. Test translation between each possible pair of
     559             :      *        encodings in file, not only into the UTF-8.
     560             :      */
     561             : 
     562           2 :     std::ifstream fin((data_ + SEP + "recode-rus.dat").c_str(),
     563           2 :                       std::ifstream::binary);
     564             :     TestRecodeStruct oReferenceString;
     565             : 
     566             :     // Read reference string (which is the first one in the file)
     567           1 :     fin.read(oReferenceString.szEncoding, sizeof(oReferenceString.szEncoding));
     568           1 :     oReferenceString.szEncoding[sizeof(oReferenceString.szEncoding) - 1] = '\0';
     569           1 :     fin.read(oReferenceString.szString, sizeof(oReferenceString.szString));
     570           1 :     oReferenceString.szString[sizeof(oReferenceString.szString) - 1] = '\0';
     571             : 
     572             :     while (true)
     573             :     {
     574             :         TestRecodeStruct oTestString;
     575             : 
     576          11 :         fin.read(oTestString.szEncoding, sizeof(oTestString.szEncoding));
     577          11 :         oTestString.szEncoding[sizeof(oTestString.szEncoding) - 1] = '\0';
     578          11 :         if (fin.eof())
     579           1 :             break;
     580          10 :         fin.read(oTestString.szString, sizeof(oTestString.szString));
     581          10 :         oTestString.szString[sizeof(oTestString.szString) - 1] = '\0';
     582             : 
     583             :         // Compare each string with the reference one
     584          10 :         CPLErrorReset();
     585             :         char *pszDecodedString =
     586          10 :             CPLRecode(oTestString.szString, oTestString.szEncoding,
     587             :                       oReferenceString.szEncoding);
     588          10 :         if (strstr(CPLGetLastErrorMsg(),
     589          20 :                    "Recode from CP1251 to UTF-8 not supported") != nullptr ||
     590          10 :             strstr(CPLGetLastErrorMsg(),
     591             :                    "Recode from KOI8-R to UTF-8 not supported") != nullptr)
     592             :         {
     593           0 :             CPLFree(pszDecodedString);
     594           0 :             break;
     595             :         }
     596             : 
     597          10 :         size_t nLength =
     598          10 :             MIN(strlen(pszDecodedString), sizeof(oReferenceString.szEncoding));
     599          10 :         bool bOK =
     600          10 :             (memcmp(pszDecodedString, oReferenceString.szString, nLength) == 0);
     601             :         // FIXME Some tests fail on Mac. Not sure why, but do not error out just
     602             :         // for that
     603          10 :         if (!bOK &&
     604           0 :             (strstr(CPLGetConfigOption("TRAVIS_OS_NAME", ""), "osx") !=
     605           0 :                  nullptr ||
     606           0 :              strstr(CPLGetConfigOption("BUILD_NAME", ""), "osx") != nullptr ||
     607           0 :              getenv("DO_NOT_FAIL_ON_RECODE_ERRORS") != nullptr))
     608             :         {
     609           0 :             fprintf(stderr, "Recode from %s failed\n", oTestString.szEncoding);
     610             :         }
     611             :         else
     612             :         {
     613             : #ifdef CPL_MSB
     614             :             if (!bOK && strcmp(oTestString.szEncoding, "UCS-2") == 0)
     615             :             {
     616             :                 // Presumably the content in the test file is UCS-2LE, but
     617             :                 // there's no way to know the byte order without a BOM
     618             :                 fprintf(stderr, "Recode from %s failed\n",
     619             :                         oTestString.szEncoding);
     620             :             }
     621             :             else
     622             : #endif
     623             :             {
     624          10 :                 EXPECT_TRUE(bOK) << "Recode from " << oTestString.szEncoding;
     625             :             }
     626             :         }
     627          10 :         CPLFree(pszDecodedString);
     628          10 :     }
     629             : 
     630           1 :     fin.close();
     631           1 : }
     632             : 
     633             : /************************************************************************/
     634             : /*                         CPLStringList tests                          */
     635             : /************************************************************************/
     636           4 : TEST_F(test_cpl, CPLStringList_Base)
     637             : {
     638           1 :     CPLStringList oCSL;
     639             : 
     640           1 :     ASSERT_TRUE(oCSL.List() == nullptr);
     641             : 
     642           1 :     oCSL.AddString("def");
     643           1 :     oCSL.AddString("abc");
     644             : 
     645           1 :     ASSERT_EQ(oCSL.Count(), 2);
     646           1 :     ASSERT_TRUE(EQUAL(oCSL[0], "def"));
     647           1 :     ASSERT_TRUE(EQUAL(oCSL[1], "abc"));
     648           1 :     ASSERT_TRUE(oCSL[17] == nullptr);
     649           1 :     ASSERT_TRUE(oCSL[-1] == nullptr);
     650           1 :     ASSERT_EQ(oCSL.FindString("abc"), 1);
     651             : 
     652           1 :     CSLDestroy(oCSL.StealList());
     653           1 :     ASSERT_EQ(oCSL.Count(), 0);
     654           1 :     ASSERT_TRUE(oCSL.List() == nullptr);
     655             : 
     656             :     // Test that the list will make an internal copy when needed to
     657             :     // modify a read-only list.
     658             : 
     659           1 :     oCSL.AddString("def");
     660           1 :     oCSL.AddString("abc");
     661             : 
     662           1 :     CPLStringList oCopy(oCSL.List(), FALSE);
     663             : 
     664           1 :     ASSERT_EQ(oCSL.List(), oCopy.List());
     665           1 :     ASSERT_EQ(oCSL.Count(), oCopy.Count());
     666             : 
     667           1 :     oCopy.AddString("xyz");
     668           1 :     ASSERT_TRUE(oCSL.List() != oCopy.List());
     669           1 :     ASSERT_EQ(oCopy.Count(), 3);
     670           1 :     ASSERT_EQ(oCSL.Count(), 2);
     671           1 :     ASSERT_TRUE(EQUAL(oCopy[2], "xyz"));
     672             : }
     673             : 
     674           4 : TEST_F(test_cpl, CPLStringList_NameValue)
     675             : {
     676             :     // Test some name=value handling stuff.
     677           1 :     CPLStringList oNVL;
     678             : 
     679           1 :     oNVL.AddNameValue("KEY1", "VALUE1");
     680           1 :     oNVL.AddNameValue("2KEY", "VALUE2");
     681           1 :     ASSERT_EQ(oNVL.Count(), 2);
     682           1 :     ASSERT_TRUE(EQUAL(oNVL.FetchNameValue("2KEY"), "VALUE2"));
     683           1 :     ASSERT_TRUE(oNVL.FetchNameValue("MISSING") == nullptr);
     684             : 
     685           1 :     oNVL.AddNameValue("KEY1", "VALUE3");
     686           1 :     ASSERT_TRUE(EQUAL(oNVL.FetchNameValue("KEY1"), "VALUE1"));
     687           1 :     ASSERT_TRUE(EQUAL(oNVL[2], "KEY1=VALUE3"));
     688           1 :     ASSERT_TRUE(EQUAL(oNVL.FetchNameValueDef("MISSING", "X"), "X"));
     689             : 
     690           1 :     oNVL.SetNameValue("2KEY", "VALUE4");
     691           1 :     ASSERT_TRUE(EQUAL(oNVL.FetchNameValue("2KEY"), "VALUE4"));
     692           1 :     ASSERT_EQ(oNVL.Count(), 3);
     693             : 
     694             :     // make sure deletion works.
     695           1 :     oNVL.SetNameValue("2KEY", nullptr);
     696           1 :     ASSERT_TRUE(oNVL.FetchNameValue("2KEY") == nullptr);
     697           1 :     ASSERT_EQ(oNVL.Count(), 2);
     698             : 
     699             :     // Test boolean support.
     700           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", TRUE), TRUE);
     701           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", FALSE), FALSE);
     702             : 
     703           1 :     oNVL.SetNameValue("BOOL", "YES");
     704           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", TRUE), TRUE);
     705           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", FALSE), TRUE);
     706             : 
     707           1 :     oNVL.SetNameValue("BOOL", "1");
     708           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", FALSE), TRUE);
     709             : 
     710           1 :     oNVL.SetNameValue("BOOL", "0");
     711           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", TRUE), FALSE);
     712             : 
     713           1 :     oNVL.SetNameValue("BOOL", "FALSE");
     714           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", TRUE), FALSE);
     715             : 
     716           1 :     oNVL.SetNameValue("BOOL", "ON");
     717           1 :     ASSERT_EQ(oNVL.FetchBoolean("BOOL", FALSE), TRUE);
     718             : 
     719             :     // Test assignment operator.
     720           1 :     CPLStringList oCopy;
     721             : 
     722             :     {
     723           2 :         CPLStringList oTemp;
     724           1 :         oTemp.AddString("test");
     725           1 :         oCopy = oTemp;
     726           1 :         oTemp.AddString("avoid_coverity_scan_warning");
     727             :     }
     728           1 :     EXPECT_STREQ(oCopy[0], "test");
     729             : 
     730           1 :     auto &oCopyRef(oCopy);
     731           1 :     oCopy = oCopyRef;
     732           1 :     EXPECT_STREQ(oCopy[0], "test");
     733             : 
     734             :     // Test copy constructor.
     735           1 :     CPLStringList oCopy2(oCopy);
     736           1 :     EXPECT_EQ(oCopy2.Count(), oCopy.Count());
     737           1 :     oCopy.Clear();
     738           1 :     EXPECT_STREQ(oCopy2[0], "test");
     739             : 
     740             :     // Test move constructor
     741           1 :     CPLStringList oMoved(std::move(oCopy2));
     742           1 :     EXPECT_STREQ(oMoved[0], "test");
     743             : 
     744             :     // Test move assignment operator
     745           1 :     CPLStringList oMoved2;
     746           1 :     oMoved2 = std::move(oMoved);
     747           1 :     EXPECT_STREQ(oMoved2[0], "test");
     748             : 
     749             :     // Test sorting
     750           1 :     CPLStringList oTestSort;
     751           1 :     oTestSort.AddNameValue("Z", "1");
     752           1 :     oTestSort.AddNameValue("L", "2");
     753           1 :     oTestSort.AddNameValue("T", "3");
     754           1 :     oTestSort.AddNameValue("A", "4");
     755           1 :     oTestSort.Sort();
     756           1 :     EXPECT_STREQ(oTestSort[0], "A=4");
     757           1 :     EXPECT_STREQ(oTestSort[1], "L=2");
     758           1 :     EXPECT_STREQ(oTestSort[2], "T=3");
     759           1 :     EXPECT_STREQ(oTestSort[3], "Z=1");
     760           1 :     ASSERT_EQ(oTestSort[4], (const char *)nullptr);
     761             : 
     762             :     // Test FetchNameValue() in a sorted list
     763           1 :     EXPECT_STREQ(oTestSort.FetchNameValue("A"), "4");
     764           1 :     EXPECT_STREQ(oTestSort.FetchNameValue("L"), "2");
     765           1 :     EXPECT_STREQ(oTestSort.FetchNameValue("T"), "3");
     766           1 :     EXPECT_STREQ(oTestSort.FetchNameValue("Z"), "1");
     767             : 
     768             :     // Test AddNameValue() in a sorted list
     769           1 :     oTestSort.AddNameValue("B", "5");
     770           1 :     EXPECT_STREQ(oTestSort[0], "A=4");
     771           1 :     EXPECT_STREQ(oTestSort[1], "B=5");
     772           1 :     EXPECT_STREQ(oTestSort[2], "L=2");
     773           1 :     EXPECT_STREQ(oTestSort[3], "T=3");
     774           1 :     EXPECT_STREQ(oTestSort[4], "Z=1");
     775           1 :     ASSERT_EQ(oTestSort[5], (const char *)nullptr);
     776             : 
     777             :     // Test SetNameValue() of an existing item in a sorted list
     778           1 :     oTestSort.SetNameValue("Z", "6");
     779           1 :     EXPECT_STREQ(oTestSort[4], "Z=6");
     780             : 
     781             :     // Test SetNameValue() of a non-existing item in a sorted list
     782           1 :     oTestSort.SetNameValue("W", "7");
     783           1 :     EXPECT_STREQ(oTestSort[0], "A=4");
     784           1 :     EXPECT_STREQ(oTestSort[1], "B=5");
     785           1 :     EXPECT_STREQ(oTestSort[2], "L=2");
     786           1 :     EXPECT_STREQ(oTestSort[3], "T=3");
     787           1 :     EXPECT_STREQ(oTestSort[4], "W=7");
     788           1 :     EXPECT_STREQ(oTestSort[5], "Z=6");
     789           1 :     ASSERT_EQ(oTestSort[6], (const char *)nullptr);
     790             : }
     791             : 
     792           4 : TEST_F(test_cpl, CPLStringList_Sort)
     793             : {
     794             :     // Test some name=value handling stuff *with* sorting active.
     795           1 :     CPLStringList oNVL;
     796             : 
     797           1 :     oNVL.Sort();
     798             : 
     799           1 :     oNVL.AddNameValue("KEY1", "VALUE1");
     800           1 :     oNVL.AddNameValue("2KEY", "VALUE2");
     801           1 :     ASSERT_EQ(oNVL.Count(), 2);
     802           1 :     EXPECT_STREQ(oNVL.FetchNameValue("KEY1"), "VALUE1");
     803           1 :     EXPECT_STREQ(oNVL.FetchNameValue("2KEY"), "VALUE2");
     804           1 :     ASSERT_TRUE(oNVL.FetchNameValue("MISSING") == nullptr);
     805             : 
     806           1 :     oNVL.AddNameValue("KEY1", "VALUE3");
     807           1 :     ASSERT_EQ(oNVL.Count(), 3);
     808           1 :     EXPECT_STREQ(oNVL.FetchNameValue("KEY1"), "VALUE1");
     809           1 :     EXPECT_STREQ(oNVL.FetchNameValueDef("MISSING", "X"), "X");
     810             : 
     811           1 :     oNVL.SetNameValue("2KEY", "VALUE4");
     812           1 :     EXPECT_STREQ(oNVL.FetchNameValue("2KEY"), "VALUE4");
     813           1 :     ASSERT_EQ(oNVL.Count(), 3);
     814             : 
     815             :     // make sure deletion works.
     816           1 :     oNVL.SetNameValue("2KEY", nullptr);
     817           1 :     ASSERT_TRUE(oNVL.FetchNameValue("2KEY") == nullptr);
     818           1 :     ASSERT_EQ(oNVL.Count(), 2);
     819             : 
     820             :     // Test insertion logic pretty carefully.
     821           1 :     oNVL.Clear();
     822           1 :     ASSERT_TRUE(oNVL.IsSorted() == TRUE);
     823             : 
     824           1 :     oNVL.SetNameValue("B", "BB");
     825           1 :     oNVL.SetNameValue("A", "AA");
     826           1 :     oNVL.SetNameValue("D", "DD");
     827           1 :     oNVL.SetNameValue("C", "CC");
     828             : 
     829             :     // items should be in sorted order.
     830           1 :     EXPECT_STREQ(oNVL[0], "A=AA");
     831           1 :     EXPECT_STREQ(oNVL[1], "B=BB");
     832           1 :     EXPECT_STREQ(oNVL[2], "C=CC");
     833           1 :     EXPECT_STREQ(oNVL[3], "D=DD");
     834             : 
     835           1 :     EXPECT_STREQ(oNVL.FetchNameValue("A"), "AA");
     836           1 :     EXPECT_STREQ(oNVL.FetchNameValue("B"), "BB");
     837           1 :     EXPECT_STREQ(oNVL.FetchNameValue("C"), "CC");
     838           1 :     EXPECT_STREQ(oNVL.FetchNameValue("D"), "DD");
     839             : }
     840             : 
     841           4 : TEST_F(test_cpl, URLEncode)
     842             : {
     843           2 :     EXPECT_STREQ(CPLString("AB").URLEncode(), "AB");
     844           2 :     EXPECT_STREQ(CPLString("A/B").URLEncode(), "A/B");
     845           2 :     EXPECT_STREQ(CPLString("A B").URLEncode(), "A%20B");
     846             : 
     847           1 :     const char *uriA =
     848             :         "http://example.com/path with space%20/pipe|/query?param=1&val=A B";
     849           1 :     const char *uriB = "http://example.com/path%20with%20space%20/pipe%7C/"
     850             :                        "query?param=1&val=A%20B";
     851           2 :     EXPECT_STREQ(CPLString(uriA).URLEncode(), uriB);
     852           2 :     EXPECT_STREQ(CPLString(uriA).URLEncode(), CPLString(uriB).URLEncode());
     853           2 :     EXPECT_STREQ(CPLString(uriA).URLEncode().URLEncode(), uriB);
     854           1 : }
     855             : 
     856           4 : TEST_F(test_cpl, CPL_HMAC_SHA256)
     857             : {
     858             :     GByte abyDigest[CPL_SHA256_HASH_SIZE];
     859             :     char szDigest[2 * CPL_SHA256_HASH_SIZE + 1];
     860             : 
     861           1 :     CPL_HMAC_SHA256("key", 3, "The quick brown fox jumps over the lazy dog",
     862             :                     strlen("The quick brown fox jumps over the lazy dog"),
     863             :                     abyDigest);
     864          33 :     for (int i = 0; i < CPL_SHA256_HASH_SIZE; i++)
     865          32 :         snprintf(szDigest + 2 * i, sizeof(szDigest) - 2 * i, "%02x",
     866          32 :                  abyDigest[i]);
     867             :     // fprintf(stderr, "%s\n", szDigest);
     868           1 :     EXPECT_STREQ(
     869             :         szDigest,
     870             :         "f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8");
     871             : 
     872           1 :     CPL_HMAC_SHA256(
     873             :         "mysupersupersupersupersupersupersupersupersupersupersupersupersupersup"
     874             :         "ersupersupersupersupersupersuperlongkey",
     875             :         strlen("mysupersupersupersupersupersupersupersupersupersupersupersupers"
     876             :                "upersupersupersupersupersupersupersuperlongkey"),
     877             :         "msg", 3, abyDigest);
     878          33 :     for (int i = 0; i < CPL_SHA256_HASH_SIZE; i++)
     879          32 :         snprintf(szDigest + 2 * i, sizeof(szDigest) - 2 * i, "%02x",
     880          32 :                  abyDigest[i]);
     881             :     // fprintf(stderr, "%s\n", szDigest);
     882           1 :     EXPECT_STREQ(
     883             :         szDigest,
     884             :         "a3051520761ed3cb43876b35ce2dd93ac5b332dc3bad898bb32086f7ac71ffc1");
     885           1 : }
     886             : 
     887           4 : TEST_F(test_cpl, VSIMalloc)
     888             : {
     889           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
     890             : 
     891             :     // The following tests will fail because of overflows
     892             : 
     893             :     {
     894           1 :         CPLErrorReset();
     895           1 :         void *ptr = VSIMalloc2(~(size_t)0, ~(size_t)0);
     896           1 :         EXPECT_EQ(ptr, nullptr);
     897           1 :         VSIFree(ptr);
     898           1 :         EXPECT_NE(CPLGetLastErrorType(), CE_None);
     899             :     }
     900             : 
     901             :     {
     902           1 :         CPLErrorReset();
     903           1 :         void *ptr = VSIMalloc3(1, ~(size_t)0, ~(size_t)0);
     904           1 :         EXPECT_EQ(ptr, nullptr);
     905           1 :         VSIFree(ptr);
     906           1 :         EXPECT_NE(CPLGetLastErrorType(), CE_None);
     907             :     }
     908             : 
     909             :     {
     910           1 :         CPLErrorReset();
     911           1 :         void *ptr = VSIMalloc3(~(size_t)0, 1, ~(size_t)0);
     912           1 :         EXPECT_EQ(ptr, nullptr);
     913           1 :         VSIFree(ptr);
     914           1 :         EXPECT_NE(CPLGetLastErrorType(), CE_None);
     915             :     }
     916             : 
     917             :     {
     918           1 :         CPLErrorReset();
     919           1 :         void *ptr = VSIMalloc3(~(size_t)0, ~(size_t)0, 1);
     920           1 :         EXPECT_EQ(ptr, nullptr);
     921           1 :         VSIFree(ptr);
     922           1 :         EXPECT_NE(CPLGetLastErrorType(), CE_None);
     923             :     }
     924             : 
     925           1 :     if (!CSLTestBoolean(CPLGetConfigOption("SKIP_MEM_INTENSIVE_TEST", "NO")))
     926             :     {
     927             :         // The following tests will fail because such allocations cannot succeed
     928             : #if SIZEOF_VOIDP == 8
     929             :         {
     930           1 :             CPLErrorReset();
     931           1 :             void *ptr = VSIMalloc(~(size_t)0);
     932           1 :             EXPECT_EQ(ptr, nullptr);
     933           1 :             VSIFree(ptr);
     934           1 :             EXPECT_EQ(CPLGetLastErrorType(), CE_None); /* no error reported */
     935             :         }
     936             : 
     937             :         {
     938           1 :             CPLErrorReset();
     939           1 :             void *ptr = VSIMalloc2(~(size_t)0, 1);
     940           1 :             EXPECT_EQ(ptr, nullptr);
     941           1 :             VSIFree(ptr);
     942           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     943             :         }
     944             : 
     945             :         {
     946           1 :             CPLErrorReset();
     947           1 :             void *ptr = VSIMalloc3(~(size_t)0, 1, 1);
     948           1 :             EXPECT_EQ(ptr, nullptr);
     949           1 :             VSIFree(ptr);
     950           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     951             :         }
     952             : 
     953             :         {
     954           1 :             CPLErrorReset();
     955           1 :             void *ptr = VSICalloc(~(size_t)0, 1);
     956           1 :             EXPECT_EQ(ptr, nullptr);
     957           1 :             VSIFree(ptr);
     958           1 :             EXPECT_EQ(CPLGetLastErrorType(), CE_None); /* no error reported */
     959             :         }
     960             : 
     961             :         {
     962           1 :             CPLErrorReset();
     963           1 :             void *ptr = VSIRealloc(nullptr, ~(size_t)0);
     964           1 :             EXPECT_EQ(ptr, nullptr);
     965           1 :             VSIFree(ptr);
     966           1 :             EXPECT_EQ(CPLGetLastErrorType(), CE_None); /* no error reported */
     967             :         }
     968             : 
     969             :         {
     970           1 :             CPLErrorReset();
     971           1 :             void *ptr = VSI_MALLOC_VERBOSE(~(size_t)0);
     972           1 :             EXPECT_EQ(ptr, nullptr);
     973           1 :             VSIFree(ptr);
     974           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     975             :         }
     976             : 
     977             :         {
     978           1 :             CPLErrorReset();
     979           1 :             void *ptr = VSI_MALLOC2_VERBOSE(~(size_t)0, 1);
     980           1 :             EXPECT_EQ(ptr, nullptr);
     981           1 :             VSIFree(ptr);
     982           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     983             :         }
     984             : 
     985             :         {
     986           1 :             CPLErrorReset();
     987           1 :             void *ptr = VSI_MALLOC3_VERBOSE(~(size_t)0, 1, 1);
     988           1 :             EXPECT_EQ(ptr, nullptr);
     989           1 :             VSIFree(ptr);
     990           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     991             :         }
     992             : 
     993             :         {
     994           1 :             CPLErrorReset();
     995           1 :             void *ptr = VSI_CALLOC_VERBOSE(~(size_t)0, 1);
     996           1 :             EXPECT_EQ(ptr, nullptr);
     997           1 :             VSIFree(ptr);
     998           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
     999             :         }
    1000             : 
    1001             :         {
    1002           1 :             CPLErrorReset();
    1003           1 :             void *ptr = VSI_REALLOC_VERBOSE(nullptr, ~(size_t)0);
    1004           1 :             EXPECT_EQ(ptr, nullptr);
    1005           1 :             VSIFree(ptr);
    1006           1 :             EXPECT_NE(CPLGetLastErrorType(), CE_None);
    1007             :         }
    1008             : #endif
    1009             :     }
    1010             : 
    1011           1 :     CPLPopErrorHandler();
    1012             : 
    1013             :     // The following allocs will return NULL because of 0 byte alloc
    1014             :     {
    1015           1 :         CPLErrorReset();
    1016           1 :         void *ptr = VSIMalloc2(0, 1);
    1017           1 :         EXPECT_EQ(ptr, nullptr);
    1018           1 :         VSIFree(ptr);
    1019           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    1020             :     }
    1021             : 
    1022             :     {
    1023           1 :         void *ptr = VSIMalloc2(1, 0);
    1024           1 :         EXPECT_EQ(ptr, nullptr);
    1025           1 :         VSIFree(ptr);
    1026             :     }
    1027             : 
    1028             :     {
    1029           1 :         CPLErrorReset();
    1030           1 :         void *ptr = VSIMalloc3(0, 1, 1);
    1031           1 :         EXPECT_EQ(ptr, nullptr);
    1032           1 :         VSIFree(ptr);
    1033           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    1034             :     }
    1035             : 
    1036             :     {
    1037           1 :         void *ptr = VSIMalloc3(1, 0, 1);
    1038           1 :         EXPECT_EQ(ptr, nullptr);
    1039           1 :         VSIFree(ptr);
    1040             :     }
    1041             : 
    1042             :     {
    1043           1 :         void *ptr = VSIMalloc3(1, 1, 0);
    1044           1 :         EXPECT_EQ(ptr, nullptr);
    1045           1 :         VSIFree(ptr);
    1046             :     }
    1047           1 : }
    1048             : 
    1049           4 : TEST_F(test_cpl, CPLFormFilename)
    1050             : {
    1051           1 :     EXPECT_TRUE(strcmp(CPLFormFilename("a", "b", nullptr), "a/b") == 0 ||
    1052             :                 strcmp(CPLFormFilename("a", "b", nullptr), "a\\b") == 0);
    1053           1 :     EXPECT_TRUE(strcmp(CPLFormFilename("a/", "b", nullptr), "a/b") == 0 ||
    1054             :                 strcmp(CPLFormFilename("a/", "b", nullptr), "a\\b") == 0);
    1055           1 :     EXPECT_TRUE(strcmp(CPLFormFilename("a\\", "b", nullptr), "a/b") == 0 ||
    1056             :                 strcmp(CPLFormFilename("a\\", "b", nullptr), "a\\b") == 0);
    1057           1 :     EXPECT_STREQ(CPLFormFilename(nullptr, "a", "b"), "a.b");
    1058           1 :     EXPECT_STREQ(CPLFormFilename(nullptr, "a", ".b"), "a.b");
    1059           1 :     EXPECT_STREQ(CPLFormFilename("/a", "..", nullptr), "/");
    1060           1 :     EXPECT_STREQ(CPLFormFilename("/a/", "..", nullptr), "/");
    1061           1 :     EXPECT_STREQ(CPLFormFilename("/a/b", "..", nullptr), "/a");
    1062           1 :     EXPECT_STREQ(CPLFormFilename("/a/b/", "..", nullptr), "/a");
    1063           1 :     EXPECT_TRUE(EQUAL(CPLFormFilename("c:", "..", nullptr), "c:/..") ||
    1064             :                 EQUAL(CPLFormFilename("c:", "..", nullptr), "c:\\.."));
    1065           1 :     EXPECT_TRUE(EQUAL(CPLFormFilename("c:\\", "..", nullptr), "c:/..") ||
    1066             :                 EQUAL(CPLFormFilename("c:\\", "..", nullptr), "c:\\.."));
    1067           1 :     EXPECT_STREQ(CPLFormFilename("c:\\a", "..", nullptr), "c:");
    1068           1 :     EXPECT_STREQ(CPLFormFilename("c:\\a\\", "..", nullptr), "c:");
    1069           1 :     EXPECT_STREQ(CPLFormFilename("c:\\a\\b", "..", nullptr), "c:\\a");
    1070           1 :     EXPECT_STREQ(CPLFormFilename("\\\\$\\c:\\a", "..", nullptr), "\\\\$\\c:");
    1071           1 :     EXPECT_TRUE(
    1072             :         EQUAL(CPLFormFilename("\\\\$\\c:", "..", nullptr), "\\\\$\\c:/..") ||
    1073             :         EQUAL(CPLFormFilename("\\\\$\\c:", "..", nullptr), "\\\\$\\c:\\.."));
    1074           1 :     EXPECT_STREQ(CPLFormFilename("/a", "../", nullptr), "/");
    1075           1 :     EXPECT_STREQ(CPLFormFilename("/a/", "../", nullptr), "/");
    1076           1 :     EXPECT_STREQ(CPLFormFilename("/a", "../b", nullptr), "/b");
    1077           1 :     EXPECT_STREQ(CPLFormFilename("/a/", "../b", nullptr), "/b");
    1078           1 :     EXPECT_STREQ(CPLFormFilename("/a", "../b/c", nullptr), "/b/c");
    1079           1 :     EXPECT_STREQ(CPLFormFilename("/a/", "../b/c/d", nullptr), "/b/c/d");
    1080           1 :     EXPECT_STREQ(CPLFormFilename("/a/b", "../../c", nullptr), "/c");
    1081           1 :     EXPECT_STREQ(CPLFormFilename("/a/b/", "../../c/d", nullptr), "/c/d");
    1082           1 :     EXPECT_STREQ(CPLFormFilename("/a/b", "../..", nullptr), "/");
    1083           1 :     EXPECT_STREQ(CPLFormFilename("/a/b", "../../", nullptr), "/");
    1084           1 :     EXPECT_STREQ(CPLFormFilename("/a/b/c", "../../d", nullptr), "/a/d");
    1085           1 :     EXPECT_STREQ(CPLFormFilename("/a/b/c/", "../../d", nullptr), "/a/d");
    1086             :     // we could also just error out, but at least this preserves the original
    1087             :     // semantics
    1088           1 :     EXPECT_STREQ(CPLFormFilename("/a", "../../b", nullptr), "/a/../../b");
    1089           1 :     EXPECT_STREQ(
    1090             :         CPLFormFilename("/vsicurl/http://example.com?foo", "bar", nullptr),
    1091             :         "/vsicurl/http://example.com/bar?foo");
    1092           1 : }
    1093             : 
    1094           4 : TEST_F(test_cpl, CPLGetPath)
    1095             : {
    1096           1 :     EXPECT_STREQ(CPLGetPath("/foo/bar/"), "/foo/bar");
    1097           1 :     EXPECT_STREQ(CPLGetPath("/foo/bar"), "/foo");
    1098           1 :     EXPECT_STREQ(CPLGetPath("/vsicurl/http://example.com/foo/bar?suffix"),
    1099             :                  "/vsicurl/http://example.com/foo?suffix");
    1100           1 :     EXPECT_STREQ(
    1101             :         CPLGetPath(
    1102             :             "/vsicurl?foo=bar&url=https%3A%2F%2Fraw.githubusercontent.com%"
    1103             :             "2FOSGeo%2Fgdal%2Fmaster%2Fautotest%2Fogr%2Fdata%2Fpoly.shp"),
    1104             :         "/vsicurl?foo=bar&url=https%3A%2F%2Fraw.githubusercontent.com%2FOSGeo%"
    1105             :         "2Fgdal%2Fmaster%2Fautotest%2Fogr%2Fdata");
    1106           1 : }
    1107             : 
    1108           4 : TEST_F(test_cpl, CPLGetDirname)
    1109             : {
    1110           1 :     EXPECT_STREQ(CPLGetDirname("/foo/bar/"), "/foo/bar");
    1111           1 :     EXPECT_STREQ(CPLGetDirname("/foo/bar"), "/foo");
    1112           1 :     EXPECT_STREQ(CPLGetDirname("/vsicurl/http://example.com/foo/bar?suffix"),
    1113             :                  "/vsicurl/http://example.com/foo?suffix");
    1114           1 :     EXPECT_STREQ(
    1115             :         CPLGetDirname(
    1116             :             "/vsicurl?foo=bar&url=https%3A%2F%2Fraw.githubusercontent.com%"
    1117             :             "2FOSGeo%2Fgdal%2Fmaster%2Fautotest%2Fogr%2Fdata%2Fpoly.shp"),
    1118             :         "/vsicurl?foo=bar&url=https%3A%2F%2Fraw.githubusercontent.com%2FOSGeo%"
    1119             :         "2Fgdal%2Fmaster%2Fautotest%2Fogr%2Fdata");
    1120           1 : }
    1121             : 
    1122           4 : TEST_F(test_cpl, VSIGetDiskFreeSpace)
    1123             : {
    1124           1 :     ASSERT_TRUE(VSIGetDiskFreeSpace("/vsimem/") > 0);
    1125           1 :     ASSERT_TRUE(VSIGetDiskFreeSpace(".") == -1 ||
    1126             :                 VSIGetDiskFreeSpace(".") >= 0);
    1127             : }
    1128             : 
    1129           4 : TEST_F(test_cpl, CPLsscanf)
    1130             : {
    1131             :     double a, b, c;
    1132             : 
    1133           1 :     a = b = 0;
    1134           1 :     ASSERT_EQ(CPLsscanf("1 2", "%lf %lf", &a, &b), 2);
    1135           1 :     ASSERT_EQ(a, 1.0);
    1136           1 :     ASSERT_EQ(b, 2.0);
    1137             : 
    1138           1 :     a = b = 0;
    1139           1 :     ASSERT_EQ(CPLsscanf("1\t2", "%lf %lf", &a, &b), 2);
    1140           1 :     ASSERT_EQ(a, 1.0);
    1141           1 :     ASSERT_EQ(b, 2.0);
    1142             : 
    1143           1 :     a = b = 0;
    1144           1 :     ASSERT_EQ(CPLsscanf("1 2", "%lf\t%lf", &a, &b), 2);
    1145           1 :     ASSERT_EQ(a, 1.0);
    1146           1 :     ASSERT_EQ(b, 2.0);
    1147             : 
    1148           1 :     a = b = 0;
    1149           1 :     ASSERT_EQ(CPLsscanf("1  2", "%lf %lf", &a, &b), 2);
    1150           1 :     ASSERT_EQ(a, 1.0);
    1151           1 :     ASSERT_EQ(b, 2.0);
    1152             : 
    1153           1 :     a = b = 0;
    1154           1 :     ASSERT_EQ(CPLsscanf("1 2", "%lf  %lf", &a, &b), 2);
    1155           1 :     ASSERT_EQ(a, 1.0);
    1156           1 :     ASSERT_EQ(b, 2.0);
    1157             : 
    1158           1 :     a = b = c = 0;
    1159           1 :     ASSERT_EQ(CPLsscanf("1 2", "%lf %lf %lf", &a, &b, &c), 2);
    1160           1 :     ASSERT_EQ(a, 1.0);
    1161           1 :     ASSERT_EQ(b, 2.0);
    1162             : }
    1163             : 
    1164           4 : TEST_F(test_cpl, CPLsnprintf)
    1165             : {
    1166             :     {
    1167             :         char buf[32];
    1168           1 :         EXPECT_EQ(CPLsnprintf(buf, sizeof(buf), "a%.*fb", 1, 2.12), 5);
    1169           1 :         EXPECT_STREQ(buf, "a2.1b");
    1170             :     }
    1171           1 : }
    1172             : 
    1173           4 : TEST_F(test_cpl, CPLSetErrorHandler)
    1174             : {
    1175           1 :     CPLString oldVal = CPLGetConfigOption("CPL_DEBUG", "");
    1176           1 :     CPLSetConfigOption("CPL_DEBUG", "TEST");
    1177             : 
    1178           1 :     CPLErrorHandler oldHandler = CPLSetErrorHandler(myErrorHandler);
    1179           1 :     gbGotError = false;
    1180           1 :     CPLDebug("TEST", "Test");
    1181           1 :     ASSERT_EQ(gbGotError, true);
    1182           1 :     gbGotError = false;
    1183           1 :     CPLSetErrorHandler(oldHandler);
    1184             : 
    1185           1 :     CPLPushErrorHandler(myErrorHandler);
    1186           1 :     gbGotError = false;
    1187           1 :     CPLDebug("TEST", "Test");
    1188           1 :     ASSERT_EQ(gbGotError, true);
    1189           1 :     gbGotError = false;
    1190           1 :     CPLPopErrorHandler();
    1191             : 
    1192           1 :     oldHandler = CPLSetErrorHandler(myErrorHandler);
    1193           1 :     CPLSetCurrentErrorHandlerCatchDebug(FALSE);
    1194           1 :     gbGotError = false;
    1195           1 :     CPLDebug("TEST", "Test");
    1196           1 :     ASSERT_EQ(gbGotError, false);
    1197           1 :     gbGotError = false;
    1198           1 :     CPLSetErrorHandler(oldHandler);
    1199             : 
    1200           1 :     CPLPushErrorHandler(myErrorHandler);
    1201           1 :     CPLSetCurrentErrorHandlerCatchDebug(FALSE);
    1202           1 :     gbGotError = false;
    1203           1 :     CPLDebug("TEST", "Test");
    1204           1 :     ASSERT_EQ(gbGotError, false);
    1205           1 :     gbGotError = false;
    1206           1 :     CPLPopErrorHandler();
    1207             : 
    1208           1 :     CPLSetConfigOption("CPL_DEBUG", oldVal.size() ? oldVal.c_str() : nullptr);
    1209             : 
    1210           1 :     oldHandler = CPLSetErrorHandler(nullptr);
    1211           1 :     CPLDebug("TEST", "Test");
    1212           1 :     CPLError(CE_Failure, CPLE_AppDefined, "test");
    1213           1 :     CPLErrorHandler newOldHandler = CPLSetErrorHandler(nullptr);
    1214           1 :     ASSERT_EQ(newOldHandler, static_cast<CPLErrorHandler>(nullptr));
    1215           1 :     CPLDebug("TEST", "Test");
    1216           1 :     CPLError(CE_Failure, CPLE_AppDefined, "test");
    1217           1 :     CPLSetErrorHandler(oldHandler);
    1218             : }
    1219             : 
    1220             : /************************************************************************/
    1221             : /*                         CPLString::replaceAll()                      */
    1222             : /************************************************************************/
    1223             : 
    1224           4 : TEST_F(test_cpl, CPLString_replaceAll)
    1225             : {
    1226           1 :     CPLString osTest;
    1227           1 :     osTest = "foobarbarfoo";
    1228           1 :     osTest.replaceAll("bar", "was_bar");
    1229           1 :     ASSERT_EQ(osTest, "foowas_barwas_barfoo");
    1230             : 
    1231           1 :     osTest = "foobarbarfoo";
    1232           1 :     osTest.replaceAll("X", "was_bar");
    1233           1 :     ASSERT_EQ(osTest, "foobarbarfoo");
    1234             : 
    1235           1 :     osTest = "foobarbarfoo";
    1236           1 :     osTest.replaceAll("", "was_bar");
    1237           1 :     ASSERT_EQ(osTest, "foobarbarfoo");
    1238             : 
    1239           1 :     osTest = "foobarbarfoo";
    1240           1 :     osTest.replaceAll("bar", "");
    1241           1 :     ASSERT_EQ(osTest, "foofoo");
    1242             : 
    1243           1 :     osTest = "foobarbarfoo";
    1244           1 :     osTest.replaceAll('b', 'B');
    1245           1 :     ASSERT_EQ(osTest, "fooBarBarfoo");
    1246             : 
    1247           1 :     osTest = "foobarbarfoo";
    1248           1 :     osTest.replaceAll('b', "B");
    1249           1 :     ASSERT_EQ(osTest, "fooBarBarfoo");
    1250             : 
    1251           1 :     osTest = "foobarbarfoo";
    1252           1 :     osTest.replaceAll("b", 'B');
    1253           1 :     ASSERT_EQ(osTest, "fooBarBarfoo");
    1254             : }
    1255             : 
    1256             : /************************************************************************/
    1257             : /*                        VSIMallocAligned()                            */
    1258             : /************************************************************************/
    1259           4 : TEST_F(test_cpl, VSIMallocAligned)
    1260             : {
    1261           1 :     GByte *ptr = static_cast<GByte *>(VSIMallocAligned(sizeof(void *), 1));
    1262           1 :     ASSERT_TRUE(ptr != nullptr);
    1263           1 :     ASSERT_TRUE(((size_t)ptr % sizeof(void *)) == 0);
    1264           1 :     *ptr = 1;
    1265           1 :     VSIFreeAligned(ptr);
    1266             : 
    1267           1 :     ptr = static_cast<GByte *>(VSIMallocAligned(16, 1));
    1268           1 :     ASSERT_TRUE(ptr != nullptr);
    1269           1 :     ASSERT_TRUE(((size_t)ptr % 16) == 0);
    1270           1 :     *ptr = 1;
    1271           1 :     VSIFreeAligned(ptr);
    1272             : 
    1273           1 :     VSIFreeAligned(nullptr);
    1274             : 
    1275             : #ifndef _WIN32
    1276             :     // Illegal use of API. Returns non NULL on Windows
    1277           1 :     ptr = static_cast<GByte *>(VSIMallocAligned(2, 1));
    1278           1 :     EXPECT_TRUE(ptr == nullptr);
    1279           1 :     VSIFree(ptr);
    1280             : 
    1281             :     // Illegal use of API. Crashes on Windows
    1282           1 :     ptr = static_cast<GByte *>(VSIMallocAligned(5, 1));
    1283           1 :     EXPECT_TRUE(ptr == nullptr);
    1284           1 :     VSIFree(ptr);
    1285             : #endif
    1286             : 
    1287           1 :     if (!CSLTestBoolean(CPLGetConfigOption("SKIP_MEM_INTENSIVE_TEST", "NO")))
    1288             :     {
    1289             :         // The following tests will fail because such allocations cannot succeed
    1290             : #if SIZEOF_VOIDP == 8
    1291             :         ptr = static_cast<GByte *>(
    1292           1 :             VSIMallocAligned(sizeof(void *), ~((size_t)0)));
    1293           1 :         EXPECT_TRUE(ptr == nullptr);
    1294           1 :         VSIFree(ptr);
    1295             : 
    1296             :         ptr = static_cast<GByte *>(
    1297           1 :             VSIMallocAligned(sizeof(void *), (~((size_t)0)) - sizeof(void *)));
    1298           1 :         EXPECT_TRUE(ptr == nullptr);
    1299           1 :         VSIFree(ptr);
    1300             : #endif
    1301             :     }
    1302             : }
    1303             : 
    1304             : /************************************************************************/
    1305             : /*             CPLGetConfigOptions() / CPLSetConfigOptions()            */
    1306             : /************************************************************************/
    1307           4 : TEST_F(test_cpl, CPLGetConfigOptions)
    1308             : {
    1309           1 :     CPLSetConfigOption("FOOFOO", "BAR");
    1310           1 :     char **options = CPLGetConfigOptions();
    1311           1 :     EXPECT_STREQ(CSLFetchNameValue(options, "FOOFOO"), "BAR");
    1312           1 :     CPLSetConfigOptions(nullptr);
    1313           1 :     EXPECT_STREQ(CPLGetConfigOption("FOOFOO", "i_dont_exist"), "i_dont_exist");
    1314           1 :     CPLSetConfigOptions(options);
    1315           1 :     EXPECT_STREQ(CPLGetConfigOption("FOOFOO", "i_dont_exist"), "BAR");
    1316           1 :     CSLDestroy(options);
    1317           1 : }
    1318             : 
    1319             : /************************************************************************/
    1320             : /*  CPLGetThreadLocalConfigOptions() / CPLSetThreadLocalConfigOptions() */
    1321             : /************************************************************************/
    1322           4 : TEST_F(test_cpl, CPLGetThreadLocalConfigOptions)
    1323             : {
    1324           1 :     CPLSetThreadLocalConfigOption("FOOFOO", "BAR");
    1325           1 :     char **options = CPLGetThreadLocalConfigOptions();
    1326           1 :     EXPECT_STREQ(CSLFetchNameValue(options, "FOOFOO"), "BAR");
    1327           1 :     CPLSetThreadLocalConfigOptions(nullptr);
    1328           1 :     EXPECT_STREQ(CPLGetThreadLocalConfigOption("FOOFOO", "i_dont_exist"),
    1329             :                  "i_dont_exist");
    1330           1 :     CPLSetThreadLocalConfigOptions(options);
    1331           1 :     EXPECT_STREQ(CPLGetThreadLocalConfigOption("FOOFOO", "i_dont_exist"),
    1332             :                  "BAR");
    1333           1 :     CSLDestroy(options);
    1334           1 : }
    1335             : 
    1336           4 : TEST_F(test_cpl, CPLExpandTilde)
    1337             : {
    1338           1 :     EXPECT_STREQ(CPLExpandTilde("/foo/bar"), "/foo/bar");
    1339             : 
    1340           1 :     CPLSetConfigOption("HOME", "/foo");
    1341           1 :     ASSERT_TRUE(EQUAL(CPLExpandTilde("~/bar"), "/foo/bar") ||
    1342             :                 EQUAL(CPLExpandTilde("~/bar"), "/foo\\bar"));
    1343           1 :     CPLSetConfigOption("HOME", nullptr);
    1344             : }
    1345             : 
    1346           4 : TEST_F(test_cpl, CPLDeclareKnownConfigOption)
    1347             : {
    1348           2 :     CPLConfigOptionSetter oDebugSetter("CPL_DEBUG", "ON", false);
    1349             :     {
    1350           2 :         CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1351           1 :         CPLErrorReset();
    1352             :         CPLConfigOptionSetter oDeclaredConfigOptionSetter("UNDECLARED_OPTION",
    1353           2 :                                                           "FOO", false);
    1354           1 :         EXPECT_STREQ(CPLGetLastErrorMsg(),
    1355             :                      "Unknown configuration option 'UNDECLARED_OPTION'.");
    1356             :     }
    1357             :     {
    1358           1 :         CPLDeclareKnownConfigOption("DECLARED_OPTION", nullptr);
    1359             : 
    1360           2 :         const CPLStringList aosKnownConfigOptions(CPLGetKnownConfigOptions());
    1361           1 :         EXPECT_GE(aosKnownConfigOptions.FindString("CPL_DEBUG"), 0);
    1362           1 :         EXPECT_GE(aosKnownConfigOptions.FindString("DECLARED_OPTION"), 0);
    1363             : 
    1364           2 :         CPLErrorStateBackuper oErrorStateBackuper(CPLQuietErrorHandler);
    1365           1 :         CPLErrorReset();
    1366             :         CPLConfigOptionSetter oDeclaredConfigOptionSetter("DECLARED_OPTION",
    1367           2 :                                                           "FOO", false);
    1368           1 :         EXPECT_STREQ(CPLGetLastErrorMsg(), "");
    1369             :     }
    1370           1 : }
    1371             : 
    1372           4 : TEST_F(test_cpl, CPLErrorSetState)
    1373             : {
    1374             :     // NOTE: Assumes cpl_error.cpp defines DEFAULT_LAST_ERR_MSG_SIZE=500
    1375           1 :     char pszMsg[] = "0abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1376             :                     "1abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1377             :                     "2abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1378             :                     "3abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1379             :                     "4abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1380             :                     "5abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1381             :                     "6abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1382             :                     "7abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1383             :                     "8abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"
    1384             :                     "9abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"  // 500
    1385             :                     "0abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*()_+=|"  // 550
    1386             :         ;
    1387             : 
    1388           1 :     CPLErrorReset();
    1389           1 :     CPLErrorSetState(CE_Warning, 1, pszMsg);
    1390           1 :     ASSERT_EQ(strlen(pszMsg) - 50 - 1,  // length - 50 - 1 (null-terminator)
    1391             :               strlen(CPLGetLastErrorMsg()));  // DEFAULT_LAST_ERR_MSG_SIZE - 1
    1392             : }
    1393             : 
    1394           4 : TEST_F(test_cpl, CPLUnescapeString)
    1395             : {
    1396           1 :     char *pszText = CPLUnescapeString(
    1397             :         "&lt;&gt;&amp;&apos;&quot;&#x3f;&#x3F;&#63;", nullptr, CPLES_XML);
    1398           1 :     EXPECT_STREQ(pszText, "<>&'\"???");
    1399           1 :     CPLFree(pszText);
    1400             : 
    1401             :     // Integer overflow
    1402           1 :     pszText = CPLUnescapeString("&10000000000000000;", nullptr, CPLES_XML);
    1403             :     // We do not really care about the return value
    1404           1 :     CPLFree(pszText);
    1405             : 
    1406             :     // Integer overflow
    1407           1 :     pszText = CPLUnescapeString("&#10000000000000000;", nullptr, CPLES_XML);
    1408             :     // We do not really care about the return value
    1409           1 :     CPLFree(pszText);
    1410             : 
    1411             :     // Error case
    1412           1 :     pszText = CPLUnescapeString("&foo", nullptr, CPLES_XML);
    1413           1 :     EXPECT_STREQ(pszText, "");
    1414           1 :     CPLFree(pszText);
    1415             : 
    1416             :     // Error case
    1417           1 :     pszText = CPLUnescapeString("&#x", nullptr, CPLES_XML);
    1418           1 :     EXPECT_STREQ(pszText, "");
    1419           1 :     CPLFree(pszText);
    1420             : 
    1421             :     // Error case
    1422           1 :     pszText = CPLUnescapeString("&#", nullptr, CPLES_XML);
    1423           1 :     EXPECT_STREQ(pszText, "");
    1424           1 :     CPLFree(pszText);
    1425           1 : }
    1426             : 
    1427             : // Test signed int safe maths
    1428           4 : TEST_F(test_cpl, CPLSM_signed)
    1429             : {
    1430           1 :     ASSERT_EQ((CPLSM(-2) + CPLSM(3)).v(), 1);
    1431           1 :     ASSERT_EQ((CPLSM(-2) + CPLSM(1)).v(), -1);
    1432           1 :     ASSERT_EQ((CPLSM(-2) + CPLSM(-1)).v(), -3);
    1433           1 :     ASSERT_EQ((CPLSM(2) + CPLSM(-3)).v(), -1);
    1434           1 :     ASSERT_EQ((CPLSM(2) + CPLSM(-1)).v(), 1);
    1435           1 :     ASSERT_EQ((CPLSM(2) + CPLSM(1)).v(), 3);
    1436           1 :     ASSERT_EQ((CPLSM(INT_MAX - 1) + CPLSM(1)).v(), INT_MAX);
    1437           1 :     ASSERT_EQ((CPLSM(1) + CPLSM(INT_MAX - 1)).v(), INT_MAX);
    1438           1 :     ASSERT_EQ((CPLSM(INT_MAX) + CPLSM(-1)).v(), INT_MAX - 1);
    1439           1 :     ASSERT_EQ((CPLSM(-1) + CPLSM(INT_MAX)).v(), INT_MAX - 1);
    1440           1 :     ASSERT_EQ((CPLSM(INT_MIN + 1) + CPLSM(-1)).v(), INT_MIN);
    1441           1 :     ASSERT_EQ((CPLSM(-1) + CPLSM(INT_MIN + 1)).v(), INT_MIN);
    1442             :     try
    1443             :     {
    1444           1 :         (CPLSM(INT_MAX) + CPLSM(1)).v();
    1445           0 :         ASSERT_TRUE(false);
    1446             :     }
    1447           1 :     catch (...)
    1448             :     {
    1449             :     }
    1450             :     try
    1451             :     {
    1452           1 :         (CPLSM(1) + CPLSM(INT_MAX)).v();
    1453           0 :         ASSERT_TRUE(false);
    1454             :     }
    1455           1 :     catch (...)
    1456             :     {
    1457             :     }
    1458             :     try
    1459             :     {
    1460           1 :         (CPLSM(INT_MIN) + CPLSM(-1)).v();
    1461           0 :         ASSERT_TRUE(false);
    1462             :     }
    1463           1 :     catch (...)
    1464             :     {
    1465             :     }
    1466             :     try
    1467             :     {
    1468           1 :         (CPLSM(-1) + CPLSM(INT_MIN)).v();
    1469           0 :         ASSERT_TRUE(false);
    1470             :     }
    1471           1 :     catch (...)
    1472             :     {
    1473             :     }
    1474             : 
    1475           1 :     ASSERT_EQ((CPLSM(-2) - CPLSM(1)).v(), -3);
    1476           1 :     ASSERT_EQ((CPLSM(-2) - CPLSM(-1)).v(), -1);
    1477           1 :     ASSERT_EQ((CPLSM(-2) - CPLSM(-3)).v(), 1);
    1478           1 :     ASSERT_EQ((CPLSM(2) - CPLSM(-1)).v(), 3);
    1479           1 :     ASSERT_EQ((CPLSM(2) - CPLSM(1)).v(), 1);
    1480           1 :     ASSERT_EQ((CPLSM(2) - CPLSM(3)).v(), -1);
    1481           1 :     ASSERT_EQ((CPLSM(INT_MAX) - CPLSM(1)).v(), INT_MAX - 1);
    1482           1 :     ASSERT_EQ((CPLSM(INT_MIN + 1) - CPLSM(1)).v(), INT_MIN);
    1483           1 :     ASSERT_EQ((CPLSM(0) - CPLSM(INT_MIN + 1)).v(), INT_MAX);
    1484           1 :     ASSERT_EQ((CPLSM(0) - CPLSM(INT_MAX)).v(), -INT_MAX);
    1485             :     try
    1486             :     {
    1487           1 :         (CPLSM(INT_MIN) - CPLSM(1)).v();
    1488           0 :         ASSERT_TRUE(false);
    1489             :     }
    1490           1 :     catch (...)
    1491             :     {
    1492             :     }
    1493             :     try
    1494             :     {
    1495           1 :         (CPLSM(0) - CPLSM(INT_MIN)).v();
    1496           0 :         ASSERT_TRUE(false);
    1497             :     }
    1498           1 :     catch (...)
    1499             :     {
    1500             :     }
    1501             :     try
    1502             :     {
    1503           1 :         (CPLSM(INT_MIN) - CPLSM(1)).v();
    1504           0 :         ASSERT_TRUE(false);
    1505             :     }
    1506           1 :     catch (...)
    1507             :     {
    1508             :     }
    1509             : 
    1510           1 :     ASSERT_EQ((CPLSM(INT_MIN + 1) * CPLSM(-1)).v(), INT_MAX);
    1511           1 :     ASSERT_EQ((CPLSM(-1) * CPLSM(INT_MIN + 1)).v(), INT_MAX);
    1512           1 :     ASSERT_EQ((CPLSM(INT_MIN) * CPLSM(1)).v(), INT_MIN);
    1513           1 :     ASSERT_EQ((CPLSM(1) * CPLSM(INT_MIN)).v(), INT_MIN);
    1514           1 :     ASSERT_EQ((CPLSM(1) * CPLSM(INT_MAX)).v(), INT_MAX);
    1515           1 :     ASSERT_EQ((CPLSM(INT_MIN / 2) * CPLSM(2)).v(), INT_MIN);
    1516           1 :     ASSERT_EQ((CPLSM(INT_MAX / 2) * CPLSM(2)).v(), INT_MAX - 1);
    1517           1 :     ASSERT_EQ((CPLSM(INT_MAX / 2 + 1) * CPLSM(-2)).v(), INT_MIN);
    1518           1 :     ASSERT_EQ((CPLSM(0) * CPLSM(INT_MIN)).v(), 0);
    1519           1 :     ASSERT_EQ((CPLSM(INT_MIN) * CPLSM(0)).v(), 0);
    1520           1 :     ASSERT_EQ((CPLSM(0) * CPLSM(INT_MAX)).v(), 0);
    1521           1 :     ASSERT_EQ((CPLSM(INT_MAX) * CPLSM(0)).v(), 0);
    1522             :     try
    1523             :     {
    1524           1 :         (CPLSM(INT_MAX / 2 + 1) * CPLSM(2)).v();
    1525           0 :         ASSERT_TRUE(false);
    1526             :     }
    1527           1 :     catch (...)
    1528             :     {
    1529             :     }
    1530             :     try
    1531             :     {
    1532           1 :         (CPLSM(2) * CPLSM(INT_MAX / 2 + 1)).v();
    1533           0 :         ASSERT_TRUE(false);
    1534             :     }
    1535           1 :     catch (...)
    1536             :     {
    1537             :     }
    1538             :     try
    1539             :     {
    1540           1 :         (CPLSM(INT_MIN) * CPLSM(-1)).v();
    1541           0 :         ASSERT_TRUE(false);
    1542             :     }
    1543           1 :     catch (...)
    1544             :     {
    1545             :     }
    1546             :     try
    1547             :     {
    1548           1 :         (CPLSM(INT_MIN) * CPLSM(2)).v();
    1549           0 :         ASSERT_TRUE(false);
    1550             :     }
    1551           1 :     catch (...)
    1552             :     {
    1553             :     }
    1554             :     try
    1555             :     {
    1556           1 :         (CPLSM(2) * CPLSM(INT_MIN)).v();
    1557           0 :         ASSERT_TRUE(false);
    1558             :     }
    1559           1 :     catch (...)
    1560             :     {
    1561             :     }
    1562             : 
    1563           1 :     ASSERT_EQ((CPLSM(4) / CPLSM(2)).v(), 2);
    1564           1 :     ASSERT_EQ((CPLSM(4) / CPLSM(-2)).v(), -2);
    1565           1 :     ASSERT_EQ((CPLSM(-4) / CPLSM(2)).v(), -2);
    1566           1 :     ASSERT_EQ((CPLSM(-4) / CPLSM(-2)).v(), 2);
    1567           1 :     ASSERT_EQ((CPLSM(0) / CPLSM(2)).v(), 0);
    1568           1 :     ASSERT_EQ((CPLSM(0) / CPLSM(-2)).v(), 0);
    1569           1 :     ASSERT_EQ((CPLSM(INT_MAX) / CPLSM(1)).v(), INT_MAX);
    1570           1 :     ASSERT_EQ((CPLSM(INT_MAX) / CPLSM(-1)).v(), -INT_MAX);
    1571           1 :     ASSERT_EQ((CPLSM(INT_MIN) / CPLSM(1)).v(), INT_MIN);
    1572             :     try
    1573             :     {
    1574           1 :         (CPLSM(-1) * CPLSM(INT_MIN)).v();
    1575           0 :         ASSERT_TRUE(false);
    1576             :     }
    1577           1 :     catch (...)
    1578             :     {
    1579             :     }
    1580             :     try
    1581             :     {
    1582           1 :         (CPLSM(INT_MIN) / CPLSM(-1)).v();
    1583           0 :         ASSERT_TRUE(false);
    1584             :     }
    1585           1 :     catch (...)
    1586             :     {
    1587             :     }
    1588             :     try
    1589             :     {
    1590           1 :         (CPLSM(1) / CPLSM(0)).v();
    1591           0 :         ASSERT_TRUE(false);
    1592             :     }
    1593           1 :     catch (...)
    1594             :     {
    1595             :     }
    1596             : 
    1597           1 :     ASSERT_EQ(CPLSM_TO_UNSIGNED(1).v(), 1U);
    1598             :     try
    1599             :     {
    1600           1 :         CPLSM_TO_UNSIGNED(-1);
    1601           0 :         ASSERT_TRUE(false);
    1602             :     }
    1603           1 :     catch (...)
    1604             :     {
    1605             :     }
    1606             : }
    1607             : 
    1608             : // Test unsigned int safe maths
    1609           4 : TEST_F(test_cpl, CPLSM_unsigned)
    1610             : {
    1611           1 :     ASSERT_EQ((CPLSM(2U) + CPLSM(3U)).v(), 5U);
    1612           1 :     ASSERT_EQ((CPLSM(UINT_MAX - 1) + CPLSM(1U)).v(), UINT_MAX);
    1613             :     try
    1614             :     {
    1615           1 :         (CPLSM(UINT_MAX) + CPLSM(1U)).v();
    1616           0 :         ASSERT_TRUE(false);
    1617             :     }
    1618           1 :     catch (...)
    1619             :     {
    1620             :     }
    1621             : 
    1622           1 :     ASSERT_EQ((CPLSM(4U) - CPLSM(3U)).v(), 1U);
    1623           1 :     ASSERT_EQ((CPLSM(4U) - CPLSM(4U)).v(), 0U);
    1624           1 :     ASSERT_EQ((CPLSM(UINT_MAX) - CPLSM(1U)).v(), UINT_MAX - 1);
    1625             :     try
    1626             :     {
    1627           1 :         (CPLSM(4U) - CPLSM(5U)).v();
    1628           0 :         ASSERT_TRUE(false);
    1629             :     }
    1630           1 :     catch (...)
    1631             :     {
    1632             :     }
    1633             : 
    1634           1 :     ASSERT_EQ((CPLSM(0U) * CPLSM(UINT_MAX)).v(), 0U);
    1635           1 :     ASSERT_EQ((CPLSM(UINT_MAX) * CPLSM(0U)).v(), 0U);
    1636           1 :     ASSERT_EQ((CPLSM(UINT_MAX) * CPLSM(1U)).v(), UINT_MAX);
    1637           1 :     ASSERT_EQ((CPLSM(1U) * CPLSM(UINT_MAX)).v(), UINT_MAX);
    1638             :     try
    1639             :     {
    1640           1 :         (CPLSM(UINT_MAX) * CPLSM(2U)).v();
    1641           0 :         ASSERT_TRUE(false);
    1642             :     }
    1643           1 :     catch (...)
    1644             :     {
    1645             :     }
    1646             :     try
    1647             :     {
    1648           1 :         (CPLSM(2U) * CPLSM(UINT_MAX)).v();
    1649           0 :         ASSERT_TRUE(false);
    1650             :     }
    1651           1 :     catch (...)
    1652             :     {
    1653             :     }
    1654             : 
    1655           1 :     ASSERT_EQ((CPLSM(4U) / CPLSM(2U)).v(), 2U);
    1656           1 :     ASSERT_EQ((CPLSM(UINT_MAX) / CPLSM(1U)).v(), UINT_MAX);
    1657             :     try
    1658             :     {
    1659           1 :         (CPLSM(1U) / CPLSM(0U)).v();
    1660           0 :         ASSERT_TRUE(false);
    1661             :     }
    1662           1 :     catch (...)
    1663             :     {
    1664             :     }
    1665             : 
    1666           1 :     ASSERT_EQ((CPLSM(static_cast<uint64_t>(2) * 1000 * 1000 * 1000) +
    1667             :                CPLSM(static_cast<uint64_t>(3) * 1000 * 1000 * 1000))
    1668             :                   .v(),
    1669             :               static_cast<uint64_t>(5) * 1000 * 1000 * 1000);
    1670           1 :     ASSERT_EQ((CPLSM(std::numeric_limits<uint64_t>::max() - 1) +
    1671             :                CPLSM(static_cast<uint64_t>(1)))
    1672             :                   .v(),
    1673             :               std::numeric_limits<uint64_t>::max());
    1674             :     try
    1675             :     {
    1676           2 :         (CPLSM(std::numeric_limits<uint64_t>::max()) +
    1677           3 :          CPLSM(static_cast<uint64_t>(1)));
    1678             :     }
    1679           1 :     catch (...)
    1680             :     {
    1681             :     }
    1682             : 
    1683           1 :     ASSERT_EQ((CPLSM(static_cast<uint64_t>(2) * 1000 * 1000 * 1000) *
    1684             :                CPLSM(static_cast<uint64_t>(3) * 1000 * 1000 * 1000))
    1685             :                   .v(),
    1686             :               static_cast<uint64_t>(6) * 1000 * 1000 * 1000 * 1000 * 1000 *
    1687             :                   1000);
    1688           1 :     ASSERT_EQ((CPLSM(std::numeric_limits<uint64_t>::max()) *
    1689             :                CPLSM(static_cast<uint64_t>(1)))
    1690             :                   .v(),
    1691             :               std::numeric_limits<uint64_t>::max());
    1692             :     try
    1693             :     {
    1694           2 :         (CPLSM(std::numeric_limits<uint64_t>::max()) *
    1695           3 :          CPLSM(static_cast<uint64_t>(2)));
    1696             :     }
    1697           1 :     catch (...)
    1698             :     {
    1699             :     }
    1700             : }
    1701             : 
    1702             : // Test CPLParseRFC822DateTime()
    1703           4 : TEST_F(test_cpl, CPLParseRFC822DateTime)
    1704             : {
    1705             :     int year, month, day, hour, min, sec, tz, weekday;
    1706           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("", &year, &month, &day, &hour, &min,
    1707             :                                         &sec, &tz, &weekday));
    1708             : 
    1709           1 :     ASSERT_EQ(CPLParseRFC822DateTime("Thu, 15 Jan 2017 12:34:56 +0015", nullptr,
    1710             :                                      nullptr, nullptr, nullptr, nullptr,
    1711             :                                      nullptr, nullptr, nullptr),
    1712             :               TRUE);
    1713             : 
    1714           1 :     ASSERT_EQ(CPLParseRFC822DateTime("Thu, 15 Jan 2017 12:34:56 +0015", &year,
    1715             :                                      &month, &day, &hour, &min, &sec, &tz,
    1716             :                                      &weekday),
    1717             :               TRUE);
    1718           1 :     ASSERT_EQ(year, 2017);
    1719           1 :     ASSERT_EQ(month, 1);
    1720           1 :     ASSERT_EQ(day, 15);
    1721           1 :     ASSERT_EQ(hour, 12);
    1722           1 :     ASSERT_EQ(min, 34);
    1723           1 :     ASSERT_EQ(sec, 56);
    1724           1 :     ASSERT_EQ(tz, 101);
    1725           1 :     ASSERT_EQ(weekday, 4);
    1726             : 
    1727           1 :     ASSERT_EQ(CPLParseRFC822DateTime("Thu, 15 Jan 2017 12:34:56 GMT", &year,
    1728             :                                      &month, &day, &hour, &min, &sec, &tz,
    1729             :                                      &weekday),
    1730             :               TRUE);
    1731           1 :     ASSERT_EQ(year, 2017);
    1732           1 :     ASSERT_EQ(month, 1);
    1733           1 :     ASSERT_EQ(day, 15);
    1734           1 :     ASSERT_EQ(hour, 12);
    1735           1 :     ASSERT_EQ(min, 34);
    1736           1 :     ASSERT_EQ(sec, 56);
    1737           1 :     ASSERT_EQ(tz, 100);
    1738           1 :     ASSERT_EQ(weekday, 4);
    1739             : 
    1740             :     // Without day of week, second and timezone
    1741           1 :     ASSERT_EQ(CPLParseRFC822DateTime("15 Jan 2017 12:34", &year, &month, &day,
    1742             :                                      &hour, &min, &sec, &tz, &weekday),
    1743             :               TRUE);
    1744           1 :     ASSERT_EQ(year, 2017);
    1745           1 :     ASSERT_EQ(month, 1);
    1746           1 :     ASSERT_EQ(day, 15);
    1747           1 :     ASSERT_EQ(hour, 12);
    1748           1 :     ASSERT_EQ(min, 34);
    1749           1 :     ASSERT_EQ(sec, -1);
    1750           1 :     ASSERT_EQ(tz, 0);
    1751           1 :     ASSERT_EQ(weekday, 0);
    1752             : 
    1753           1 :     ASSERT_EQ(CPLParseRFC822DateTime("XXX, 15 Jan 2017 12:34:56 GMT", &year,
    1754             :                                      &month, &day, &hour, &min, &sec, &tz,
    1755             :                                      &weekday),
    1756             :               TRUE);
    1757           1 :     ASSERT_EQ(weekday, 0);
    1758             : 
    1759           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("Sun, 01 Jan 2017 12", &year, &month,
    1760             :                                         &day, &hour, &min, &sec, &tz,
    1761             :                                         &weekday));
    1762             : 
    1763           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("00 Jan 2017 12:34:56 GMT", &year,
    1764             :                                         &month, &day, &hour, &min, &sec, &tz,
    1765             :                                         &weekday));
    1766             : 
    1767           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("32 Jan 2017 12:34:56 GMT", &year,
    1768             :                                         &month, &day, &hour, &min, &sec, &tz,
    1769             :                                         &weekday));
    1770             : 
    1771           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 XXX 2017 12:34:56 GMT", &year,
    1772             :                                         &month, &day, &hour, &min, &sec, &tz,
    1773             :                                         &weekday));
    1774             : 
    1775           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 -1:34:56 GMT", &year,
    1776             :                                         &month, &day, &hour, &min, &sec, &tz,
    1777             :                                         &weekday));
    1778             : 
    1779           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 24:34:56 GMT", &year,
    1780             :                                         &month, &day, &hour, &min, &sec, &tz,
    1781             :                                         &weekday));
    1782             : 
    1783           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 12:-1:56 GMT", &year,
    1784             :                                         &month, &day, &hour, &min, &sec, &tz,
    1785             :                                         &weekday));
    1786             : 
    1787           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 12:60:56 GMT", &year,
    1788             :                                         &month, &day, &hour, &min, &sec, &tz,
    1789             :                                         &weekday));
    1790             : 
    1791           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 12:34:-1 GMT", &year,
    1792             :                                         &month, &day, &hour, &min, &sec, &tz,
    1793             :                                         &weekday));
    1794             : 
    1795           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("01 Jan 2017 12:34:61 GMT", &year,
    1796             :                                         &month, &day, &hour, &min, &sec, &tz,
    1797             :                                         &weekday));
    1798             : 
    1799           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("15 Jan 2017 12:34:56 XXX", &year,
    1800             :                                         &month, &day, &hour, &min, &sec, &tz,
    1801             :                                         &weekday));
    1802             : 
    1803           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("15 Jan 2017 12:34:56 +-100", &year,
    1804             :                                         &month, &day, &hour, &min, &sec, &tz,
    1805             :                                         &weekday));
    1806             : 
    1807           1 :     ASSERT_TRUE(!CPLParseRFC822DateTime("15 Jan 2017 12:34:56 +9900", &year,
    1808             :                                         &month, &day, &hour, &min, &sec, &tz,
    1809             :                                         &weekday));
    1810             : }
    1811             : 
    1812             : // Test CPLParseMemorySize()
    1813           4 : TEST_F(test_cpl, CPLParseMemorySize)
    1814             : {
    1815             :     GIntBig nValue;
    1816             :     bool bUnitSpecified;
    1817             :     CPLErr result;
    1818             : 
    1819           1 :     result = CPLParseMemorySize("327mb", &nValue, &bUnitSpecified);
    1820           1 :     EXPECT_EQ(result, CE_None);
    1821           1 :     EXPECT_EQ(nValue, 327 * 1024 * 1024);
    1822           1 :     EXPECT_TRUE(bUnitSpecified);
    1823             : 
    1824           1 :     result = CPLParseMemorySize("327MB", &nValue, &bUnitSpecified);
    1825           1 :     EXPECT_EQ(result, CE_None);
    1826           1 :     EXPECT_EQ(nValue, 327 * 1024 * 1024);
    1827           1 :     EXPECT_TRUE(bUnitSpecified);
    1828             : 
    1829           1 :     result = CPLParseMemorySize("102.9K", &nValue, &bUnitSpecified);
    1830           1 :     EXPECT_EQ(result, CE_None);
    1831           1 :     EXPECT_EQ(nValue, static_cast<GIntBig>(102.9 * 1024));
    1832           1 :     EXPECT_TRUE(bUnitSpecified);
    1833             : 
    1834           1 :     result = CPLParseMemorySize("102.9 kB", &nValue, &bUnitSpecified);
    1835           1 :     EXPECT_EQ(result, CE_None);
    1836           1 :     EXPECT_EQ(nValue, static_cast<GIntBig>(102.9 * 1024));
    1837           1 :     EXPECT_TRUE(bUnitSpecified);
    1838             : 
    1839           1 :     result = CPLParseMemorySize("100%", &nValue, &bUnitSpecified);
    1840           1 :     EXPECT_EQ(result, CE_None);
    1841           1 :     EXPECT_GT(nValue, 100 * 1024 * 1024);
    1842           1 :     EXPECT_TRUE(bUnitSpecified);
    1843             : 
    1844           1 :     result = CPLParseMemorySize("0", &nValue, &bUnitSpecified);
    1845           1 :     EXPECT_EQ(result, CE_None);
    1846           1 :     EXPECT_EQ(nValue, 0);
    1847           1 :     EXPECT_FALSE(bUnitSpecified);
    1848             : 
    1849           1 :     result = CPLParseMemorySize("0MB", &nValue, &bUnitSpecified);
    1850           1 :     EXPECT_EQ(result, CE_None);
    1851           1 :     EXPECT_EQ(nValue, 0);
    1852           1 :     EXPECT_TRUE(bUnitSpecified);
    1853             : 
    1854           1 :     result = CPLParseMemorySize("  802  ", &nValue, &bUnitSpecified);
    1855           1 :     EXPECT_EQ(result, CE_None);
    1856           1 :     EXPECT_EQ(nValue, 802);
    1857           1 :     EXPECT_FALSE(bUnitSpecified);
    1858             : 
    1859           1 :     result = CPLParseMemorySize("110%", &nValue, &bUnitSpecified);
    1860           1 :     EXPECT_EQ(result, CE_Failure);
    1861             : 
    1862           1 :     result = CPLParseMemorySize("8kbit", &nValue, &bUnitSpecified);
    1863           1 :     EXPECT_EQ(result, CE_Failure);
    1864             : 
    1865           1 :     result = CPLParseMemorySize("8ZB", &nValue, &bUnitSpecified);
    1866           1 :     EXPECT_EQ(result, CE_Failure);
    1867             : 
    1868           1 :     result = CPLParseMemorySize("8Z", &nValue, &bUnitSpecified);
    1869           1 :     EXPECT_EQ(result, CE_Failure);
    1870             : 
    1871           1 :     result = CPLParseMemorySize("", &nValue, &bUnitSpecified);
    1872           1 :     EXPECT_EQ(result, CE_Failure);
    1873             : 
    1874           1 :     result = CPLParseMemorySize("  ", &nValue, &bUnitSpecified);
    1875           1 :     EXPECT_EQ(result, CE_Failure);
    1876             : 
    1877           1 :     result = CPLParseMemorySize("-100MB", &nValue, &bUnitSpecified);
    1878           1 :     EXPECT_EQ(result, CE_Failure);
    1879             : 
    1880           1 :     result = CPLParseMemorySize("nan", &nValue, &bUnitSpecified);
    1881           1 :     EXPECT_EQ(result, CE_Failure);
    1882           1 : }
    1883             : 
    1884             : // Test CPLCopyTree()
    1885           4 : TEST_F(test_cpl, CPLCopyTree)
    1886             : {
    1887           1 :     CPLString osTmpPath(CPLGetDirname(CPLGenerateTempFilename(nullptr)));
    1888           1 :     CPLString osSrcDir(CPLFormFilename(osTmpPath, "src_dir", nullptr));
    1889           1 :     CPLString osNewDir(CPLFormFilename(osTmpPath, "new_dir", nullptr));
    1890           1 :     CPLString osSrcFile(CPLFormFilename(osSrcDir, "my.bin", nullptr));
    1891           1 :     CPLString osNewFile(CPLFormFilename(osNewDir, "my.bin", nullptr));
    1892             : 
    1893             :     // Cleanup if previous test failed
    1894           1 :     VSIUnlink(osNewFile);
    1895           1 :     VSIRmdir(osNewDir);
    1896           1 :     VSIUnlink(osSrcFile);
    1897           1 :     VSIRmdir(osSrcDir);
    1898             : 
    1899           1 :     ASSERT_TRUE(VSIMkdir(osSrcDir, 0755) == 0);
    1900           1 :     VSILFILE *fp = VSIFOpenL(osSrcFile, "wb");
    1901           1 :     ASSERT_TRUE(fp != nullptr);
    1902           1 :     VSIFCloseL(fp);
    1903             : 
    1904           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    1905           1 :     ASSERT_TRUE(CPLCopyTree(osNewDir, "/i/do_not/exist") < 0);
    1906           1 :     CPLPopErrorHandler();
    1907             : 
    1908           1 :     ASSERT_TRUE(CPLCopyTree(osNewDir, osSrcDir) == 0);
    1909             :     VSIStatBufL sStat;
    1910           1 :     ASSERT_TRUE(VSIStatL(osNewFile, &sStat) == 0);
    1911             : 
    1912           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    1913           1 :     ASSERT_TRUE(CPLCopyTree(osNewDir, osSrcDir) < 0);
    1914           1 :     CPLPopErrorHandler();
    1915             : 
    1916           1 :     VSIUnlink(osNewFile);
    1917           1 :     VSIRmdir(osNewDir);
    1918           1 :     VSIUnlink(osSrcFile);
    1919           1 :     VSIRmdir(osSrcDir);
    1920             : }
    1921             : 
    1922             : class CPLJSonStreamingParserDump : public CPLJSonStreamingParser
    1923             : {
    1924             :     std::vector<bool> m_abFirstMember;
    1925             :     CPLString m_osSerialized;
    1926             :     CPLString m_osException;
    1927             : 
    1928             :   public:
    1929          76 :     CPLJSonStreamingParserDump()
    1930          76 :     {
    1931          76 :     }
    1932             : 
    1933          23 :     virtual void Reset() override
    1934             :     {
    1935          23 :         m_osSerialized.clear();
    1936          23 :         m_osException.clear();
    1937          23 :         CPLJSonStreamingParser::Reset();
    1938          23 :     }
    1939             : 
    1940             :     virtual void String(std::string_view s) override;
    1941             :     virtual void Number(std::string_view s) override;
    1942             :     virtual void Boolean(bool bVal) override;
    1943             :     virtual void Null() override;
    1944             : 
    1945             :     virtual void StartObject() override;
    1946             :     virtual void EndObject() override;
    1947             :     virtual void StartObjectMember(std::string_view key) override;
    1948             : 
    1949             :     virtual void StartArray() override;
    1950             :     virtual void EndArray() override;
    1951             :     virtual void StartArrayMember() override;
    1952             : 
    1953             :     virtual void Exception(const char *pszMessage) override;
    1954             : 
    1955          46 :     const CPLString &GetSerialized() const
    1956             :     {
    1957          46 :         return m_osSerialized;
    1958             :     }
    1959             : 
    1960          53 :     const CPLString &GetException() const
    1961             :     {
    1962          53 :         return m_osException;
    1963             :     }
    1964             : };
    1965             : 
    1966          19 : void CPLJSonStreamingParserDump::StartObject()
    1967             : {
    1968          19 :     m_osSerialized += "{";
    1969          19 :     m_abFirstMember.push_back(true);
    1970          19 : }
    1971             : 
    1972           8 : void CPLJSonStreamingParserDump::EndObject()
    1973             : {
    1974           8 :     m_osSerialized += "}";
    1975           8 :     m_abFirstMember.pop_back();
    1976           8 : }
    1977             : 
    1978          16 : void CPLJSonStreamingParserDump::StartObjectMember(std::string_view key)
    1979             : {
    1980          16 :     if (!m_abFirstMember.back())
    1981           4 :         m_osSerialized += ", ";
    1982          16 :     m_osSerialized += '"';
    1983          16 :     m_osSerialized += key;
    1984          16 :     m_osSerialized += "\": ";
    1985          16 :     m_abFirstMember.back() = false;
    1986          16 : }
    1987             : 
    1988          14 : void CPLJSonStreamingParserDump::String(std::string_view v)
    1989             : {
    1990          14 :     m_osSerialized += GetSerializedString(v);
    1991          14 : }
    1992             : 
    1993          22 : void CPLJSonStreamingParserDump::Number(std::string_view v)
    1994             : {
    1995          22 :     m_osSerialized += v;
    1996          22 : }
    1997             : 
    1998           8 : void CPLJSonStreamingParserDump::Boolean(bool bVal)
    1999             : {
    2000           8 :     m_osSerialized += bVal ? "true" : "false";
    2001           8 : }
    2002             : 
    2003           6 : void CPLJSonStreamingParserDump::Null()
    2004             : {
    2005           6 :     m_osSerialized += "null";
    2006           6 : }
    2007             : 
    2008          20 : void CPLJSonStreamingParserDump::StartArray()
    2009             : {
    2010          20 :     m_osSerialized += "[";
    2011          20 :     m_abFirstMember.push_back(true);
    2012          20 : }
    2013             : 
    2014          12 : void CPLJSonStreamingParserDump::EndArray()
    2015             : {
    2016          12 :     m_osSerialized += "]";
    2017          12 :     m_abFirstMember.pop_back();
    2018          12 : }
    2019             : 
    2020          14 : void CPLJSonStreamingParserDump::StartArrayMember()
    2021             : {
    2022          14 :     if (!m_abFirstMember.back())
    2023           2 :         m_osSerialized += ", ";
    2024          14 :     m_abFirstMember.back() = false;
    2025          14 : }
    2026             : 
    2027          53 : void CPLJSonStreamingParserDump::Exception(const char *pszMessage)
    2028             : {
    2029          53 :     m_osException = pszMessage;
    2030          53 : }
    2031             : 
    2032             : // Test CPLJSonStreamingParser()
    2033           4 : TEST_F(test_cpl, CPLJSonStreamingParser)
    2034             : {
    2035             :     // nominal cases
    2036             : 
    2037             :     const auto NominalCase =
    2038          23 :         [](const std::string &s, const std::string &sExpected = std::string())
    2039             :     {
    2040          46 :         CPLJSonStreamingParserDump oParser;
    2041          23 :         EXPECT_TRUE(oParser.Parse(s, true));
    2042          23 :         if (!sExpected.empty())
    2043           8 :             EXPECT_STREQ(oParser.GetSerialized(), sExpected.c_str());
    2044             :         else
    2045          15 :             EXPECT_STREQ(oParser.GetSerialized(), s.c_str());
    2046             : 
    2047          23 :         oParser.Reset();
    2048         257 :         for (size_t i = 0; i < s.size(); i++)
    2049             :         {
    2050         234 :             EXPECT_TRUE(oParser.Parse(std::string_view(s.c_str() + i, 1),
    2051             :                                       i + 1 == s.size()));
    2052             :         }
    2053          23 :         if (!sExpected.empty())
    2054           8 :             EXPECT_STREQ(oParser.GetSerialized(), sExpected.c_str());
    2055             :         else
    2056          15 :             EXPECT_STREQ(oParser.GetSerialized(), s.c_str());
    2057          23 :     };
    2058             : 
    2059           1 :     NominalCase("false");
    2060           1 :     NominalCase("true");
    2061           1 :     NominalCase("null");
    2062           1 :     NominalCase("10");
    2063           1 :     NominalCase("123eE-34");
    2064           1 :     NominalCase("\"\"");
    2065           1 :     NominalCase("\"simple string\"");
    2066           1 :     NominalCase("");
    2067           1 :     NominalCase("\"\\\\a\\b\\f\\n\\r\\t\\u0020\\u0001\\\"\"",
    2068             :                 "\"\\\\a\\b\\f\\n\\r\\t \\u0001\\\"\"");
    2069           1 :     NominalCase(
    2070             :         "\"\\u0001\\u0020\\ud834\\uDD1E\\uDD1E\\uD834\\uD834\\uD834\"",
    2071             :         "\"\\u0001 \xf0\x9d\x84\x9e\xef\xbf\xbd\xef\xbf\xbd\xef\xbf\xbd\"");
    2072           1 :     NominalCase("\"\\ud834\"", "\"\xef\xbf\xbd\"");
    2073           1 :     NominalCase("\"\\ud834\\t\"", "\"\xef\xbf\xbd\\t\"");
    2074           1 :     NominalCase("\"\\u00e9\"", "\"\xc3\xa9\"");
    2075           1 :     NominalCase("{}");
    2076           1 :     NominalCase("[]");
    2077           1 :     NominalCase("[[]]");
    2078           1 :     NominalCase("[1]");
    2079           1 :     NominalCase("[1,2]", "[1, 2]");
    2080           1 :     NominalCase("{\"a\":null}", "{\"a\": null}");
    2081           1 :     NominalCase(" { \"a\" : null ,\r\n\t\"b\": {\"c\": 1}, \"d\": [1] }",
    2082             :                 "{\"a\": null, \"b\": {\"c\": 1}, \"d\": [1]}");
    2083           1 :     NominalCase("infinity");
    2084           1 :     NominalCase("-infinity");
    2085           1 :     NominalCase("nan");
    2086             : 
    2087             :     // errors
    2088             : 
    2089          49 :     const auto ErrorCase = [](const std::string &s)
    2090             :     {
    2091          98 :         CPLJSonStreamingParserDump oParser;
    2092          49 :         EXPECT_FALSE(oParser.Parse(s, true));
    2093          49 :         EXPECT_FALSE(oParser.GetException().empty());
    2094          49 :     };
    2095             : 
    2096           1 :     ErrorCase("tru");
    2097           1 :     ErrorCase("tru1");
    2098           1 :     ErrorCase("truxe");
    2099           1 :     ErrorCase("truex");
    2100           1 :     ErrorCase("fals");
    2101           1 :     ErrorCase("falsxe");
    2102           1 :     ErrorCase("falsex");
    2103           1 :     ErrorCase("nul");
    2104           1 :     ErrorCase("nulxl");
    2105           1 :     ErrorCase("nullx");
    2106           1 :     ErrorCase("na");
    2107           1 :     ErrorCase("nanx");
    2108           1 :     ErrorCase("naxn");
    2109           1 :     ErrorCase("infinit");
    2110           1 :     ErrorCase("infinityx");
    2111           1 :     ErrorCase("-infinit");
    2112           1 :     ErrorCase("-infinityx");
    2113           1 :     ErrorCase("true false");
    2114           1 :     ErrorCase("x");
    2115           1 :     ErrorCase("{");
    2116           1 :     ErrorCase("}");
    2117           1 :     ErrorCase("[");
    2118           1 :     ErrorCase("[1");
    2119           1 :     ErrorCase("[,");
    2120           1 :     ErrorCase("[|");
    2121           1 :     ErrorCase("]");
    2122           1 :     ErrorCase("{ :");
    2123           1 :     ErrorCase("{ ,");
    2124           1 :     ErrorCase("{ |");
    2125           1 :     ErrorCase("{ 1");
    2126           1 :     ErrorCase("{ \"x\"");
    2127           1 :     ErrorCase("{ \"x\": ");
    2128           1 :     ErrorCase("{ \"x\": 1 2");
    2129           1 :     ErrorCase("{ \"x\" }");
    2130           1 :     ErrorCase("{ \"x\", ");
    2131           1 :     ErrorCase("{ \"a\" x}");
    2132           1 :     ErrorCase("1x");
    2133           1 :     ErrorCase("\"");
    2134           1 :     ErrorCase("\"\\");
    2135           1 :     ErrorCase("\"\\x\"");
    2136           1 :     ErrorCase("\"\\u");
    2137           1 :     ErrorCase("\"\\ux");
    2138           1 :     ErrorCase("\"\\u000");
    2139           1 :     ErrorCase("\"\\uD834\\ux\"");
    2140           1 :     ErrorCase("\"\\\"");
    2141           1 :     ErrorCase("[,]");
    2142           1 :     ErrorCase("[true,]");
    2143           1 :     ErrorCase("[true,,true]");
    2144           1 :     ErrorCase("[true true]");
    2145             : 
    2146             :     {
    2147           1 :         CPLJSonStreamingParserDump oParser;
    2148           1 :         oParser.SetMaxStringSize(2);
    2149           1 :         ASSERT_TRUE(!oParser.Parse("\"too long\"", true));
    2150           1 :         ASSERT_TRUE(!oParser.GetException().empty());
    2151             :     }
    2152             :     {
    2153           1 :         CPLJSonStreamingParserDump oParser;
    2154           1 :         oParser.SetMaxStringSize(2);
    2155           1 :         ASSERT_TRUE(oParser.Parse("\"", false));
    2156           1 :         ASSERT_TRUE(!oParser.Parse("too long\"", true));
    2157           1 :         ASSERT_TRUE(!oParser.GetException().empty());
    2158             :     }
    2159             :     {
    2160           1 :         CPLJSonStreamingParserDump oParser;
    2161           1 :         oParser.SetMaxDepth(1);
    2162           1 :         ASSERT_TRUE(!oParser.Parse("[[]]", true));
    2163           1 :         ASSERT_TRUE(!oParser.GetException().empty());
    2164             :     }
    2165             :     {
    2166           1 :         CPLJSonStreamingParserDump oParser;
    2167           1 :         oParser.SetMaxDepth(1);
    2168           1 :         ASSERT_TRUE(!oParser.Parse("{ \"x\": {} }", true));
    2169           1 :         ASSERT_TRUE(!oParser.GetException().empty());
    2170             :     }
    2171             : }
    2172             : 
    2173             : // Test cpl_mem_cache
    2174           4 : TEST_F(test_cpl, cpl_mem_cache)
    2175             : {
    2176           1 :     lru11::Cache<int, int> cache(2, 1);
    2177           1 :     ASSERT_EQ(cache.size(), 0U);
    2178           1 :     ASSERT_TRUE(cache.empty());
    2179           1 :     cache.clear();
    2180             :     int val;
    2181           1 :     ASSERT_TRUE(!cache.tryGet(0, val));
    2182             :     try
    2183             :     {
    2184           1 :         cache.get(0);
    2185           0 :         ASSERT_TRUE(false);
    2186             :     }
    2187           2 :     catch (const lru11::KeyNotFound &)
    2188             :     {
    2189           1 :         ASSERT_TRUE(true);
    2190             :     }
    2191           1 :     ASSERT_TRUE(!cache.remove(0));
    2192           1 :     ASSERT_TRUE(!cache.contains(0));
    2193           1 :     ASSERT_EQ(cache.getMaxSize(), 2U);
    2194           1 :     ASSERT_EQ(cache.getElasticity(), 1U);
    2195           1 :     ASSERT_EQ(cache.getMaxAllowedSize(), 3U);
    2196             :     int out;
    2197           1 :     ASSERT_TRUE(!cache.removeAndRecycleOldestEntry(out));
    2198             : 
    2199           1 :     cache.insert(0, 1);
    2200           1 :     val = 0;
    2201           1 :     ASSERT_TRUE(cache.tryGet(0, val));
    2202           1 :     int *ptr = cache.getPtr(0);
    2203           1 :     ASSERT_TRUE(ptr);
    2204           1 :     ASSERT_EQ(*ptr, 1);
    2205           1 :     ASSERT_TRUE(cache.getPtr(-1) == nullptr);
    2206           1 :     ASSERT_EQ(val, 1);
    2207           1 :     ASSERT_EQ(cache.get(0), 1);
    2208           1 :     ASSERT_EQ(cache.getCopy(0), 1);
    2209           1 :     ASSERT_EQ(cache.size(), 1U);
    2210           1 :     ASSERT_TRUE(!cache.empty());
    2211           1 :     ASSERT_TRUE(cache.contains(0));
    2212           1 :     bool visited = false;
    2213           2 :     auto lambda = [&visited](const lru11::KeyValuePair<int, int> &kv)
    2214             :     {
    2215           1 :         if (kv.key == 0 && kv.value == 1)
    2216           1 :             visited = true;
    2217           2 :     };
    2218           1 :     cache.cwalk(lambda);
    2219           1 :     ASSERT_TRUE(visited);
    2220             : 
    2221           1 :     out = -1;
    2222           1 :     ASSERT_TRUE(cache.removeAndRecycleOldestEntry(out));
    2223           1 :     ASSERT_EQ(out, 1);
    2224             : 
    2225           1 :     cache.insert(0, 1);
    2226           1 :     cache.insert(0, 2);
    2227           1 :     ASSERT_EQ(cache.get(0), 2);
    2228           1 :     ASSERT_EQ(cache.size(), 1U);
    2229           1 :     cache.insert(1, 3);
    2230           1 :     cache.insert(2, 4);
    2231           1 :     ASSERT_EQ(cache.size(), 3U);
    2232           1 :     cache.insert(3, 5);
    2233           1 :     ASSERT_EQ(cache.size(), 2U);
    2234           1 :     ASSERT_TRUE(cache.contains(2));
    2235           1 :     ASSERT_TRUE(cache.contains(3));
    2236           1 :     ASSERT_TRUE(!cache.contains(0));
    2237           1 :     ASSERT_TRUE(!cache.contains(1));
    2238           1 :     ASSERT_TRUE(cache.remove(2));
    2239           1 :     ASSERT_TRUE(!cache.contains(2));
    2240           1 :     ASSERT_EQ(cache.size(), 1U);
    2241             : 
    2242             :     {
    2243             :         // Check that MyObj copy constructor and copy-assignment operator
    2244             :         // are not needed
    2245             :         struct MyObj
    2246             :         {
    2247             :             int m_v;
    2248             : 
    2249           4 :             MyObj(int v) : m_v(v)
    2250             :             {
    2251           4 :             }
    2252             : 
    2253             :             MyObj(const MyObj &) = delete;
    2254             :             MyObj &operator=(const MyObj &) = delete;
    2255             :             MyObj(MyObj &&) = default;
    2256             :             MyObj &operator=(MyObj &&) = default;
    2257             :         };
    2258             : 
    2259           1 :         lru11::Cache<int, MyObj> cacheMyObj(2, 0);
    2260           1 :         ASSERT_EQ(cacheMyObj.insert(0, MyObj(0)).m_v, 0);
    2261           1 :         cacheMyObj.getPtr(0);
    2262           1 :         ASSERT_EQ(cacheMyObj.insert(1, MyObj(1)).m_v, 1);
    2263           1 :         ASSERT_EQ(cacheMyObj.insert(2, MyObj(2)).m_v, 2);
    2264           1 :         MyObj outObj(-1);
    2265           1 :         cacheMyObj.removeAndRecycleOldestEntry(outObj);
    2266             :     }
    2267             : 
    2268             :     {
    2269             :         // Check that MyObj copy constructor and copy-assignment operator
    2270             :         // are not triggered
    2271             :         struct MyObj
    2272             :         {
    2273             :             int m_v;
    2274             : 
    2275           4 :             MyObj(int v) : m_v(v)
    2276             :             {
    2277           4 :             }
    2278             : 
    2279             :             static void should_not_happen()
    2280             :             {
    2281             :                 ASSERT_TRUE(false);
    2282             :             }
    2283             : 
    2284             :             MyObj(const MyObj &) : m_v(-1)
    2285             :             {
    2286             :                 should_not_happen();
    2287             :             }
    2288             : 
    2289             :             MyObj &operator=(const MyObj &)
    2290             :             {
    2291             :                 should_not_happen();
    2292             :                 return *this;
    2293             :             }
    2294             : 
    2295             :             MyObj(MyObj &&) = default;
    2296             :             MyObj &operator=(MyObj &&) = default;
    2297             :         };
    2298             : 
    2299           1 :         lru11::Cache<int, MyObj> cacheMyObj(2, 0);
    2300           1 :         ASSERT_EQ(cacheMyObj.insert(0, MyObj(0)).m_v, 0);
    2301           1 :         cacheMyObj.getPtr(0);
    2302           1 :         ASSERT_EQ(cacheMyObj.insert(1, MyObj(1)).m_v, 1);
    2303           1 :         ASSERT_EQ(cacheMyObj.insert(2, MyObj(2)).m_v, 2);
    2304           1 :         MyObj outObj(-1);
    2305           1 :         cacheMyObj.removeAndRecycleOldestEntry(outObj);
    2306             :     }
    2307             : }
    2308             : 
    2309             : // Test CPLJSONDocument
    2310           4 : TEST_F(test_cpl, CPLJSONDocument)
    2311             : {
    2312             :     {
    2313             :         // Test Json document LoadUrl
    2314           1 :         CPLJSONDocument oDocument;
    2315           1 :         const char *options[5] = {"CONNECTTIMEOUT=15", "TIMEOUT=20",
    2316             :                                   "MAX_RETRY=5", "RETRY_DELAY=1", nullptr};
    2317             : 
    2318           1 :         oDocument.GetRoot().Add("foo", "bar");
    2319             : 
    2320           1 :         if (CPLHTTPEnabled())
    2321             :         {
    2322           1 :             CPLSetConfigOption("CPL_CURL_ENABLE_VSIMEM", "YES");
    2323           1 :             VSILFILE *fpTmp = VSIFOpenL("/vsimem/test.json", "wb");
    2324           1 :             const char *pszContent = "{ \"foo\": \"bar\" }";
    2325           1 :             VSIFWriteL(pszContent, 1, strlen(pszContent), fpTmp);
    2326           1 :             VSIFCloseL(fpTmp);
    2327           1 :             ASSERT_TRUE(oDocument.LoadUrl("/vsimem/test.json",
    2328             :                                           const_cast<char **>(options)));
    2329           1 :             CPLSetConfigOption("CPL_CURL_ENABLE_VSIMEM", nullptr);
    2330           1 :             VSIUnlink("/vsimem/test.json");
    2331             : 
    2332           1 :             CPLJSONObject oJsonRoot = oDocument.GetRoot();
    2333           1 :             ASSERT_TRUE(oJsonRoot.IsValid());
    2334             : 
    2335           2 :             CPLString value = oJsonRoot.GetString("foo", "");
    2336           1 :             ASSERT_STRNE(value, "bar");  // not equal
    2337             :         }
    2338             :     }
    2339             :     {
    2340             :         // Test Json document LoadChunks
    2341           1 :         CPLJSONDocument oDocument;
    2342             : 
    2343           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
    2344           1 :         ASSERT_TRUE(!oDocument.LoadChunks("/i_do/not/exist", 512));
    2345           1 :         CPLPopErrorHandler();
    2346             : 
    2347           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
    2348           1 :         ASSERT_TRUE(!oDocument.LoadChunks("test_cpl.cpp", 512));
    2349           1 :         CPLPopErrorHandler();
    2350             : 
    2351           1 :         oDocument.GetRoot().Add("foo", "bar");
    2352             : 
    2353           1 :         ASSERT_TRUE(
    2354             :             oDocument.LoadChunks((data_ + SEP + "test.json").c_str(), 512));
    2355             : 
    2356           1 :         CPLJSONObject oJsonRoot = oDocument.GetRoot();
    2357           1 :         ASSERT_TRUE(oJsonRoot.IsValid());
    2358           1 :         ASSERT_EQ(oJsonRoot.GetInteger("resource/id", 10), 0);
    2359             : 
    2360           2 :         CPLJSONObject oJsonResource = oJsonRoot.GetObj("resource");
    2361           1 :         ASSERT_TRUE(oJsonResource.IsValid());
    2362           1 :         std::vector<CPLJSONObject> children = oJsonResource.GetChildren();
    2363           1 :         ASSERT_TRUE(children.size() == 11);
    2364             : 
    2365           2 :         CPLJSONArray oaScopes = oJsonRoot.GetArray("resource/scopes");
    2366           1 :         ASSERT_TRUE(oaScopes.IsValid());
    2367           1 :         ASSERT_EQ(oaScopes.Size(), 2);
    2368             : 
    2369           2 :         CPLJSONObject oHasChildren = oJsonRoot.GetObj("resource/children");
    2370           1 :         ASSERT_TRUE(oHasChildren.IsValid());
    2371           1 :         ASSERT_EQ(oHasChildren.ToBool(), true);
    2372             : 
    2373           1 :         ASSERT_EQ(oJsonResource.GetBool("children", false), true);
    2374             : 
    2375           2 :         CPLJSONObject oJsonId = oJsonRoot["resource/owner_user/id"];
    2376           1 :         ASSERT_TRUE(oJsonId.IsValid());
    2377             :     }
    2378             :     {
    2379           1 :         CPLJSONDocument oDocument;
    2380           1 :         ASSERT_TRUE(!oDocument.LoadMemory(nullptr, 0));
    2381           1 :         ASSERT_TRUE(!oDocument.LoadMemory(CPLString()));
    2382           1 :         ASSERT_TRUE(oDocument.LoadMemory(std::string("true")));
    2383           1 :         ASSERT_TRUE(oDocument.GetRoot().GetType() ==
    2384             :                     CPLJSONObject::Type::Boolean);
    2385           1 :         ASSERT_TRUE(oDocument.GetRoot().ToBool());
    2386           1 :         ASSERT_TRUE(oDocument.LoadMemory(std::string("false")));
    2387           1 :         ASSERT_TRUE(oDocument.GetRoot().GetType() ==
    2388             :                     CPLJSONObject::Type::Boolean);
    2389           1 :         ASSERT_TRUE(!oDocument.GetRoot().ToBool());
    2390             :     }
    2391             :     {
    2392             :         // Copy constructor
    2393           1 :         CPLJSONDocument oDocument;
    2394           1 :         ASSERT_TRUE(oDocument.LoadMemory(std::string("true")));
    2395           1 :         oDocument.GetRoot();
    2396           1 :         CPLJSONDocument oDocument2(oDocument);
    2397           1 :         CPLJSONObject oObj(oDocument.GetRoot());
    2398           1 :         ASSERT_TRUE(oObj.ToBool());
    2399           1 :         CPLJSONObject oObj2(oObj);
    2400           1 :         ASSERT_TRUE(oObj2.ToBool());
    2401             :         // Assignment operator
    2402           1 :         oDocument2 = oDocument;
    2403           1 :         oDocument.GetRoot();  // avoid Coverity Scan warning
    2404           1 :         auto &oDocument2Ref(oDocument2);
    2405           1 :         oDocument2 = oDocument2Ref;
    2406           1 :         oObj2 = oObj;
    2407           1 :         oObj.GetType();  // avoid Coverity Scan warning
    2408           1 :         auto &oObj2Ref(oObj2);
    2409           1 :         oObj2 = oObj2Ref;
    2410           1 :         CPLJSONObject oObj3(std::move(oObj2));
    2411           1 :         ASSERT_TRUE(oObj3.ToBool());
    2412           1 :         CPLJSONObject oObj4;
    2413           1 :         oObj4 = std::move(oObj3);
    2414           1 :         ASSERT_TRUE(oObj4.ToBool());
    2415             :     }
    2416             :     {
    2417             :         // Move constructor
    2418           2 :         CPLJSONDocument oDocument;
    2419           1 :         oDocument.GetRoot();
    2420           1 :         CPLJSONDocument oDocument2(std::move(oDocument));
    2421             :     }
    2422             :     {
    2423             :         // Move assignment
    2424           2 :         CPLJSONDocument oDocument;
    2425           1 :         oDocument.GetRoot();
    2426           2 :         CPLJSONDocument oDocument2;
    2427           1 :         oDocument2 = std::move(oDocument);
    2428             :     }
    2429             :     {
    2430             :         // Save
    2431           1 :         CPLJSONDocument oDocument;
    2432           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
    2433           1 :         ASSERT_TRUE(!oDocument.Save("/i_do/not/exist"));
    2434           1 :         CPLPopErrorHandler();
    2435             :     }
    2436             :     {
    2437           2 :         CPLJSONObject oObj(nullptr);
    2438           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::Null);
    2439             :     }
    2440             :     {
    2441           2 :         CPLJSONObject oObj(true);
    2442           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::Boolean);
    2443           1 :         EXPECT_EQ(oObj.ToBool(), true);
    2444             :     }
    2445             :     {
    2446           2 :         CPLJSONObject oObj(1);
    2447           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::Integer);
    2448           1 :         EXPECT_EQ(oObj.ToInteger(), 1);
    2449             :     }
    2450             :     {
    2451           2 :         CPLJSONObject oObj(static_cast<int64_t>(123) * 1024 * 1024 * 1024);
    2452           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::Long);
    2453           1 :         EXPECT_EQ(oObj.ToLong(),
    2454             :                   static_cast<int64_t>(123) * 1024 * 1024 * 1024);
    2455             :     }
    2456             :     {
    2457           2 :         CPLJSONObject oObj(static_cast<uint64_t>(123) * 1024 * 1024 * 1024);
    2458             :         // Might be a string with older libjson versions
    2459           1 :         if (oObj.GetType() == CPLJSONObject::Type::Long)
    2460             :         {
    2461           1 :             EXPECT_EQ(oObj.ToLong(),
    2462             :                       static_cast<int64_t>(123) * 1024 * 1024 * 1024);
    2463             :         }
    2464             :     }
    2465             :     {
    2466           2 :         CPLJSONObject oObj(1.5);
    2467           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::Double);
    2468           1 :         EXPECT_EQ(oObj.ToDouble(), 1.5);
    2469             :     }
    2470             :     {
    2471           2 :         CPLJSONObject oObj("ab");
    2472           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::String);
    2473           2 :         EXPECT_STREQ(oObj.ToString().c_str(), "ab");
    2474             :     }
    2475             :     {
    2476           3 :         CPLJSONObject oObj(std::string("ab"));
    2477           1 :         EXPECT_EQ(oObj.GetType(), CPLJSONObject::Type::String);
    2478           2 :         EXPECT_STREQ(oObj.ToString().c_str(), "ab");
    2479             :     }
    2480             :     {
    2481           1 :         CPLJSONObject oObj;
    2482           1 :         oObj.Add("string", std::string("my_string"));
    2483           2 :         ASSERT_EQ(oObj.GetString("string"), std::string("my_string"));
    2484           2 :         ASSERT_EQ(oObj.GetString("inexisting_string", "default"),
    2485             :                   std::string("default"));
    2486           1 :         oObj.Add("const_char_star", nullptr);
    2487           1 :         oObj.Add("const_char_star", "my_const_char_star");
    2488           1 :         ASSERT_TRUE(oObj.GetObj("const_char_star").GetType() ==
    2489             :                     CPLJSONObject::Type::String);
    2490           1 :         oObj.Add("int", 1);
    2491           1 :         ASSERT_EQ(oObj.GetInteger("int"), 1);
    2492           1 :         ASSERT_EQ(oObj.GetInteger("inexisting_int", -987), -987);
    2493           1 :         ASSERT_TRUE(oObj.GetObj("int").GetType() ==
    2494             :                     CPLJSONObject::Type::Integer);
    2495           1 :         oObj.Add("int64", GINT64_MAX);
    2496           2 :         ASSERT_EQ(oObj.GetLong("int64"), GINT64_MAX);
    2497           2 :         ASSERT_EQ(oObj.GetLong("inexisting_int64", GINT64_MIN), GINT64_MIN);
    2498           1 :         ASSERT_TRUE(oObj.GetObj("int64").GetType() ==
    2499             :                     CPLJSONObject::Type::Long);
    2500           1 :         oObj.Add("double", 1.25);
    2501           1 :         ASSERT_EQ(oObj.GetDouble("double"), 1.25);
    2502           1 :         ASSERT_EQ(oObj.GetDouble("inexisting_double", -987.0), -987.0);
    2503           1 :         ASSERT_TRUE(oObj.GetObj("double").GetType() ==
    2504             :                     CPLJSONObject::Type::Double);
    2505           1 :         oObj.Add("array", CPLJSONArray());
    2506           1 :         ASSERT_TRUE(oObj.GetObj("array").GetType() ==
    2507             :                     CPLJSONObject::Type::Array);
    2508           1 :         oObj.Add("obj", CPLJSONObject());
    2509           1 :         ASSERT_TRUE(oObj.GetObj("obj").GetType() ==
    2510             :                     CPLJSONObject::Type::Object);
    2511           1 :         oObj.Add("bool", true);
    2512           1 :         ASSERT_EQ(oObj.GetBool("bool"), true);
    2513           1 :         ASSERT_EQ(oObj.GetBool("inexisting_bool", false), false);
    2514           1 :         ASSERT_TRUE(oObj.GetObj("bool").GetType() ==
    2515             :                     CPLJSONObject::Type::Boolean);
    2516           1 :         oObj.AddNull("null_field");
    2517           1 :         ASSERT_TRUE(oObj.GetObj("null_field").GetType() ==
    2518             :                     CPLJSONObject::Type::Null);
    2519           1 :         ASSERT_TRUE(oObj.GetObj("inexisting").GetType() ==
    2520             :                     CPLJSONObject::Type::Unknown);
    2521           1 :         oObj.Set("string", std::string("my_string"));
    2522           1 :         oObj.Set("const_char_star", nullptr);
    2523           1 :         oObj.Set("const_char_star", "my_const_char_star");
    2524           1 :         oObj.Set("int", 1);
    2525           1 :         oObj.Set("int64", GINT64_MAX);
    2526           1 :         oObj.Set("double", 1.25);
    2527             :         // oObj.Set("array", CPLJSONArray());
    2528             :         // oObj.Set("obj", CPLJSONObject());
    2529           1 :         oObj.Set("bool", true);
    2530           1 :         oObj.SetNull("null_field");
    2531           1 :         ASSERT_TRUE(CPLJSONArray().GetChildren().empty());
    2532           1 :         oObj.ToArray();
    2533             :     }
    2534             :     {
    2535           2 :         CPLJSONObject oObj;
    2536           1 :         oObj.Set("foo", "bar");
    2537           2 :         EXPECT_STREQ(oObj.Format(CPLJSONObject::PrettyFormat::Spaced).c_str(),
    2538             :                      "{ \"foo\": \"bar\" }");
    2539           2 :         EXPECT_STREQ(oObj.Format(CPLJSONObject::PrettyFormat::Pretty).c_str(),
    2540             :                      "{\n  \"foo\":\"bar\"\n}");
    2541           2 :         EXPECT_STREQ(oObj.Format(CPLJSONObject::PrettyFormat::Plain).c_str(),
    2542             :                      "{\"foo\":\"bar\"}");
    2543             :     }
    2544             :     {
    2545           2 :         CPLJSONArray oArrayConstructorString(std::string("foo"));
    2546           1 :         CPLJSONArray oArray;
    2547           1 :         oArray.Add(CPLJSONObject());
    2548           1 :         oArray.Add(std::string("str"));
    2549           1 :         oArray.Add("const_char_star");
    2550           1 :         oArray.Add(1.25);
    2551           1 :         oArray.Add(1);
    2552           1 :         oArray.Add(GINT64_MAX);
    2553           1 :         oArray.Add(true);
    2554           1 :         oArray.AddNull();
    2555           1 :         ASSERT_EQ(oArray.Size(), 8);
    2556             : 
    2557           1 :         int nCount = 0;
    2558           9 :         for (const auto &obj : oArray)
    2559             :         {
    2560           8 :             ASSERT_EQ(obj.GetInternalHandle(),
    2561             :                       oArray[nCount].GetInternalHandle());
    2562           8 :             nCount++;
    2563             :         }
    2564           1 :         ASSERT_EQ(nCount, 8);
    2565             :     }
    2566             :     {
    2567           1 :         CPLJSONDocument oDocument;
    2568           1 :         ASSERT_TRUE(oDocument.LoadMemory(CPLString("{ \"/foo\" : \"bar\" }")));
    2569           2 :         ASSERT_EQ(oDocument.GetRoot().GetString("/foo"), std::string("bar"));
    2570             :     }
    2571             : }
    2572             : 
    2573             : // Test CPLRecodeIconv() with re-allocation
    2574             : // (this test also passed on Windows using its native recoding API)
    2575           4 : TEST_F(test_cpl, CPLRecodeIconv)
    2576             : {
    2577             : #if defined(CPL_RECODE_ICONV) || defined(_WIN32)
    2578           1 :     int N = 32800;
    2579           1 :     char *pszIn = static_cast<char *>(CPLMalloc(N + 1));
    2580       32801 :     for (int i = 0; i < N; i++)
    2581       32800 :         pszIn[i] = '\xA1';
    2582           1 :     pszIn[N] = 0;
    2583           1 :     char *pszExpected = static_cast<char *>(CPLMalloc(N * 2 + 1));
    2584       32801 :     for (int i = 0; i < N; i++)
    2585             :     {
    2586       32800 :         pszExpected[2 * i] = '\xD0';
    2587       32800 :         pszExpected[2 * i + 1] = '\x81';
    2588             :     }
    2589           1 :     pszExpected[N * 2] = 0;
    2590           1 :     char *pszRet = CPLRecode(pszIn, "ISO-8859-5", CPL_ENC_UTF8);
    2591           1 :     EXPECT_EQ(memcmp(pszExpected, pszRet, N * 2 + 1), 0);
    2592           1 :     CPLFree(pszIn);
    2593           1 :     CPLFree(pszRet);
    2594           1 :     CPLFree(pszExpected);
    2595             : #else
    2596             :     GTEST_SKIP() << "CPL_RECODE_ICONV missing";
    2597             : #endif
    2598           1 : }
    2599             : 
    2600             : // Test CP1252 to UTF-8
    2601           4 : TEST_F(test_cpl, CPLRecodeStubCP1252_to_UTF8_strict_alloc)
    2602             : {
    2603           1 :     CPLClearRecodeWarningFlags();
    2604           1 :     CPLErrorReset();
    2605           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2606             :     // Euro character expands to 3-bytes
    2607           1 :     char *pszRet = CPLRecode("\x80", "CP1252", CPL_ENC_UTF8);
    2608           1 :     CPLPopErrorHandler();
    2609           1 :     EXPECT_STREQ(CPLGetLastErrorMsg(), "");
    2610           1 :     EXPECT_EQ(memcmp(pszRet, "\xE2\x82\xAC\x00", 4), 0);
    2611           1 :     CPLFree(pszRet);
    2612           1 : }
    2613             : 
    2614             : // Test CP1252 to UTF-8
    2615           4 : TEST_F(test_cpl, CPLRecodeStubCP1252_to_UTF8_with_ascii)
    2616             : {
    2617           1 :     CPLClearRecodeWarningFlags();
    2618           1 :     CPLErrorReset();
    2619           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2620           1 :     char *pszRet = CPLRecode("x\x80y", "CP1252", CPL_ENC_UTF8);
    2621           1 :     CPLPopErrorHandler();
    2622           1 :     EXPECT_STREQ(CPLGetLastErrorMsg(), "");
    2623           1 :     EXPECT_EQ(memcmp(pszRet, "x\xE2\x82\xACy\x00", 6), 0);
    2624           1 :     CPLFree(pszRet);
    2625           1 : }
    2626             : 
    2627             : // Test CP1252 to UTF-8
    2628           4 : TEST_F(test_cpl, CPLRecodeStubCP1252_to_UTF8_with_warning)
    2629             : {
    2630           1 :     CPLClearRecodeWarningFlags();
    2631           1 :     CPLErrorReset();
    2632           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2633             :     // \x90 is an invalid CP1252 character. Will be skipped
    2634           1 :     char *pszRet = CPLRecode("\x90\x80", "CP1252", CPL_ENC_UTF8);
    2635           1 :     CPLPopErrorHandler();
    2636           1 :     EXPECT_STREQ(
    2637             :         CPLGetLastErrorMsg(),
    2638             :         "One or several characters couldn't be converted correctly from CP1252 "
    2639             :         "to UTF-8. This warning will not be emitted anymore");
    2640           1 :     EXPECT_EQ(memcmp(pszRet, "\xE2\x82\xAC\x00", 4), 0);
    2641           1 :     CPLFree(pszRet);
    2642           1 : }
    2643             : 
    2644             : // Test CPLHTTPParseMultipartMime()
    2645           4 : TEST_F(test_cpl, CPLHTTPParseMultipartMime)
    2646             : {
    2647             :     CPLHTTPResult *psResult;
    2648             : 
    2649             :     psResult =
    2650           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2651           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2652           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2653           1 :     CPLPopErrorHandler();
    2654           1 :     CPLHTTPDestroyResult(psResult);
    2655             : 
    2656             :     // Missing boundary value
    2657             :     psResult =
    2658           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2659           1 :     psResult->pszContentType = CPLStrdup("multipart/form-data; boundary=");
    2660           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2661           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2662           1 :     CPLPopErrorHandler();
    2663           1 :     CPLHTTPDestroyResult(psResult);
    2664             : 
    2665             :     // No content
    2666             :     psResult =
    2667           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2668           1 :     psResult->pszContentType =
    2669           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2670           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2671           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2672           1 :     CPLPopErrorHandler();
    2673           1 :     CPLHTTPDestroyResult(psResult);
    2674             : 
    2675             :     // No part
    2676             :     psResult =
    2677           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2678           1 :     psResult->pszContentType =
    2679           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2680             :     {
    2681           1 :         const char *pszText = "--myboundary  some junk\r\n";
    2682           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2683           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2684             :     }
    2685           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2686           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2687           1 :     CPLPopErrorHandler();
    2688           1 :     CPLHTTPDestroyResult(psResult);
    2689             : 
    2690             :     // Missing end boundary
    2691             :     psResult =
    2692           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2693           1 :     psResult->pszContentType =
    2694           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2695             :     {
    2696           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2697             :                               "\r\n"
    2698             :                               "Bla";
    2699           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2700           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2701             :     }
    2702           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2703           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2704           1 :     CPLPopErrorHandler();
    2705           1 :     CPLHTTPDestroyResult(psResult);
    2706             : 
    2707             :     // Truncated header
    2708             :     psResult =
    2709           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2710           1 :     psResult->pszContentType =
    2711           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2712             :     {
    2713           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2714             :                               "Content-Type: foo";
    2715           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2716           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2717             :     }
    2718           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2719           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2720           1 :     CPLPopErrorHandler();
    2721           1 :     CPLHTTPDestroyResult(psResult);
    2722             : 
    2723             :     // Invalid end boundary
    2724             :     psResult =
    2725           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2726           1 :     psResult->pszContentType =
    2727           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2728             :     {
    2729           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2730             :                               "\r\n"
    2731             :                               "Bla"
    2732             :                               "\r\n"
    2733             :                               "--myboundary";
    2734           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2735           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2736             :     }
    2737           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2738           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2739           1 :     CPLPopErrorHandler();
    2740           1 :     CPLHTTPDestroyResult(psResult);
    2741             : 
    2742             :     // Invalid end boundary
    2743             :     psResult =
    2744           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2745           1 :     psResult->pszContentType =
    2746           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2747             :     {
    2748           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2749             :                               "\r\n"
    2750             :                               "Bla"
    2751             :                               "\r\n"
    2752             :                               "--myboundary";
    2753           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2754           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2755             :     }
    2756           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2757           1 :     EXPECT_TRUE(!CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2758           1 :     CPLPopErrorHandler();
    2759           1 :     CPLHTTPDestroyResult(psResult);
    2760             : 
    2761             :     // Valid single part, no header
    2762             :     psResult =
    2763           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2764           1 :     psResult->pszContentType =
    2765           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2766             :     {
    2767           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2768             :                               "\r\n"
    2769             :                               "Bla"
    2770             :                               "\r\n"
    2771             :                               "--myboundary--\r\n";
    2772           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2773           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2774             :     }
    2775           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2776           1 :     EXPECT_EQ(psResult->nMimePartCount, 1);
    2777           1 :     if (psResult->nMimePartCount == 1)
    2778             :     {
    2779           1 :         EXPECT_EQ(psResult->pasMimePart[0].papszHeaders,
    2780             :                   static_cast<char **>(nullptr));
    2781           1 :         EXPECT_EQ(psResult->pasMimePart[0].nDataLen, 3);
    2782           1 :         EXPECT_TRUE(
    2783             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[0].pabyData),
    2784             :                     "Bla", 3) == 0);
    2785             :     }
    2786           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2787           1 :     CPLHTTPDestroyResult(psResult);
    2788             : 
    2789             :     // Valid single part, with header
    2790             :     psResult =
    2791           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2792           1 :     psResult->pszContentType =
    2793           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2794             :     {
    2795           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2796             :                               "Content-Type: bla\r\n"
    2797             :                               "\r\n"
    2798             :                               "Bla"
    2799             :                               "\r\n"
    2800             :                               "--myboundary--\r\n";
    2801           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2802           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2803             :     }
    2804           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2805           1 :     EXPECT_EQ(psResult->nMimePartCount, 1);
    2806           1 :     if (psResult->nMimePartCount == 1)
    2807             :     {
    2808           1 :         EXPECT_EQ(CSLCount(psResult->pasMimePart[0].papszHeaders), 1);
    2809           1 :         EXPECT_STREQ(psResult->pasMimePart[0].papszHeaders[0],
    2810             :                      "Content-Type=bla");
    2811           1 :         EXPECT_EQ(psResult->pasMimePart[0].nDataLen, 3);
    2812           1 :         EXPECT_TRUE(
    2813             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[0].pabyData),
    2814             :                     "Bla", 3) == 0);
    2815             :     }
    2816           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2817           1 :     CPLHTTPDestroyResult(psResult);
    2818             : 
    2819             :     // Valid single part, 2 headers
    2820             :     psResult =
    2821           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2822           1 :     psResult->pszContentType =
    2823           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2824             :     {
    2825           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2826             :                               "Content-Type: bla\r\n"
    2827             :                               "Content-Disposition: bar\r\n"
    2828             :                               "\r\n"
    2829             :                               "Bla"
    2830             :                               "\r\n"
    2831             :                               "--myboundary--\r\n";
    2832           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2833           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2834             :     }
    2835           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2836           1 :     EXPECT_EQ(psResult->nMimePartCount, 1);
    2837           1 :     if (psResult->nMimePartCount == 1)
    2838             :     {
    2839           1 :         EXPECT_EQ(CSLCount(psResult->pasMimePart[0].papszHeaders), 2);
    2840           1 :         EXPECT_STREQ(psResult->pasMimePart[0].papszHeaders[0],
    2841             :                      "Content-Type=bla");
    2842           1 :         EXPECT_STREQ(psResult->pasMimePart[0].papszHeaders[1],
    2843             :                      "Content-Disposition=bar");
    2844           1 :         EXPECT_EQ(psResult->pasMimePart[0].nDataLen, 3);
    2845           1 :         EXPECT_TRUE(
    2846             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[0].pabyData),
    2847             :                     "Bla", 3) == 0);
    2848             :     }
    2849           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2850           1 :     CPLHTTPDestroyResult(psResult);
    2851             : 
    2852             :     // Single part, but with header without extra terminating \r\n
    2853             :     // (invalid normally, but apparently necessary for some ArcGIS WCS
    2854             :     // implementations)
    2855             :     psResult =
    2856           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2857           1 :     psResult->pszContentType =
    2858           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2859             :     {
    2860           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2861             :                               "Content-Type: bla\r\n"
    2862             :                               "Bla"
    2863             :                               "\r\n"
    2864             :                               "--myboundary--\r\n";
    2865           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2866           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2867             :     }
    2868           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2869           1 :     EXPECT_EQ(psResult->nMimePartCount, 1);
    2870           1 :     if (psResult->nMimePartCount == 1)
    2871             :     {
    2872           1 :         EXPECT_STREQ(psResult->pasMimePart[0].papszHeaders[0],
    2873             :                      "Content-Type=bla");
    2874           1 :         EXPECT_EQ(psResult->pasMimePart[0].nDataLen, 3);
    2875           1 :         EXPECT_TRUE(
    2876             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[0].pabyData),
    2877             :                     "Bla", 3) == 0);
    2878             :     }
    2879           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2880           1 :     CPLHTTPDestroyResult(psResult);
    2881             : 
    2882             :     // Valid 2 parts, no header
    2883             :     psResult =
    2884           1 :         static_cast<CPLHTTPResult *>(CPLCalloc(1, sizeof(CPLHTTPResult)));
    2885           1 :     psResult->pszContentType =
    2886           1 :         CPLStrdup("multipart/form-data; boundary=myboundary");
    2887             :     {
    2888           1 :         const char *pszText = "--myboundary  some junk\r\n"
    2889             :                               "\r\n"
    2890             :                               "Bla"
    2891             :                               "\r\n"
    2892             :                               "--myboundary\r\n"
    2893             :                               "\r\n"
    2894             :                               "second part"
    2895             :                               "\r\n"
    2896             :                               "--myboundary--\r\n";
    2897           1 :         psResult->pabyData = reinterpret_cast<GByte *>(CPLStrdup(pszText));
    2898           1 :         psResult->nDataLen = static_cast<int>(strlen(pszText));
    2899             :     }
    2900           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2901           1 :     EXPECT_EQ(psResult->nMimePartCount, 2);
    2902           1 :     if (psResult->nMimePartCount == 2)
    2903             :     {
    2904           1 :         EXPECT_EQ(psResult->pasMimePart[0].papszHeaders,
    2905             :                   static_cast<char **>(nullptr));
    2906           1 :         EXPECT_EQ(psResult->pasMimePart[0].nDataLen, 3);
    2907           1 :         EXPECT_TRUE(
    2908             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[0].pabyData),
    2909             :                     "Bla", 3) == 0);
    2910           1 :         EXPECT_EQ(psResult->pasMimePart[1].nDataLen, 11);
    2911           1 :         EXPECT_TRUE(
    2912             :             strncmp(reinterpret_cast<char *>(psResult->pasMimePart[1].pabyData),
    2913             :                     "second part", 11) == 0);
    2914             :     }
    2915           1 :     EXPECT_TRUE(CPL_TO_BOOL(CPLHTTPParseMultipartMime(psResult)));
    2916           1 :     CPLHTTPDestroyResult(psResult);
    2917           1 : }
    2918             : 
    2919             : // Test cpl::down_cast
    2920           4 : TEST_F(test_cpl, down_cast)
    2921             : {
    2922             :     struct Base
    2923             :     {
    2924           2 :         virtual ~Base()
    2925           2 :         {
    2926           2 :         }
    2927             :     };
    2928             : 
    2929             :     struct Derived : public Base
    2930             :     {
    2931             :     };
    2932             : 
    2933           0 :     Base b;
    2934           0 :     Derived d;
    2935           1 :     Base *p_b_d = &d;
    2936             : 
    2937             : #ifdef wont_compile
    2938             :     struct OtherBase
    2939             :     {
    2940             :     };
    2941             : 
    2942             :     OtherBase ob;
    2943             :     ASSERT_EQ(cpl::down_cast<OtherBase *>(p_b_d), &ob);
    2944             : #endif
    2945             : #ifdef compile_with_warning
    2946             :     ASSERT_EQ(cpl::down_cast<Base *>(p_b_d), p_b_d);
    2947             : #endif
    2948           1 :     ASSERT_EQ(cpl::down_cast<Derived *>(p_b_d), &d);
    2949           1 :     ASSERT_EQ(cpl::down_cast<Derived *>(static_cast<Base *>(nullptr)),
    2950             :               static_cast<Derived *>(nullptr));
    2951             : }
    2952             : 
    2953             : // Test CPLPrintTime() in particular case of RFC822 formatting in C locale
    2954           4 : TEST_F(test_cpl, CPLPrintTime_RFC822)
    2955             : {
    2956             :     char szDate[64];
    2957             :     struct tm tm;
    2958           1 :     tm.tm_sec = 56;
    2959           1 :     tm.tm_min = 34;
    2960           1 :     tm.tm_hour = 12;
    2961           1 :     tm.tm_mday = 20;
    2962           1 :     tm.tm_mon = 6 - 1;
    2963           1 :     tm.tm_year = 2018 - 1900;
    2964           1 :     tm.tm_wday = 3;   // Wednesday
    2965           1 :     tm.tm_yday = 0;   // unused
    2966           1 :     tm.tm_isdst = 0;  // unused
    2967           1 :     int nRet = CPLPrintTime(szDate, sizeof(szDate) - 1,
    2968             :                             "%a, %d %b %Y %H:%M:%S GMT", &tm, "C");
    2969           1 :     szDate[nRet] = 0;
    2970           1 :     ASSERT_STREQ(szDate, "Wed, 20 Jun 2018 12:34:56 GMT");
    2971             : }
    2972             : 
    2973             : // Test CPLAutoClose
    2974           4 : TEST_F(test_cpl, CPLAutoClose)
    2975             : {
    2976             :     static int counter = 0;
    2977             : 
    2978             :     class AutoCloseTest
    2979             :     {
    2980             :       public:
    2981           2 :         AutoCloseTest()
    2982           2 :         {
    2983           2 :             counter += 222;
    2984           2 :         }
    2985             : 
    2986           4 :         virtual ~AutoCloseTest()
    2987           2 :         {
    2988           2 :             counter -= 22;
    2989           4 :         }
    2990             : 
    2991           2 :         static AutoCloseTest *Create()
    2992             :         {
    2993           2 :             return new AutoCloseTest;
    2994             :         }
    2995             : 
    2996           2 :         static void Destroy(AutoCloseTest *p)
    2997             :         {
    2998           2 :             delete p;
    2999           2 :         }
    3000             :     };
    3001             : 
    3002             :     {
    3003           1 :         AutoCloseTest *p1 = AutoCloseTest::Create();
    3004           2 :         CPL_AUTO_CLOSE_WARP(p1, AutoCloseTest::Destroy);
    3005             : 
    3006           1 :         AutoCloseTest *p2 = AutoCloseTest::Create();
    3007           1 :         CPL_AUTO_CLOSE_WARP(p2, AutoCloseTest::Destroy);
    3008             :     }
    3009           1 :     ASSERT_EQ(counter, 400);
    3010             : }
    3011             : 
    3012             : // Test cpl_minixml
    3013           4 : TEST_F(test_cpl, cpl_minixml)
    3014             : {
    3015           1 :     CPLXMLNode *psRoot = CPLCreateXMLNode(nullptr, CXT_Element, "Root");
    3016           1 :     CPLXMLNode *psElt = CPLCreateXMLElementAndValue(psRoot, "Elt", "value");
    3017           1 :     CPLAddXMLAttributeAndValue(psElt, "attr1", "val1");
    3018           1 :     CPLAddXMLAttributeAndValue(psElt, "attr2", "val2");
    3019           1 :     EXPECT_GE(CPLXMLNodeGetRAMUsageEstimate(psRoot), 0);
    3020           1 :     char *str = CPLSerializeXMLTree(psRoot);
    3021           1 :     CPLDestroyXMLNode(psRoot);
    3022           1 :     ASSERT_STREQ(
    3023             :         str,
    3024             :         "<Root>\n  <Elt attr1=\"val1\" attr2=\"val2\">value</Elt>\n</Root>\n");
    3025           1 :     CPLFree(str);
    3026             : }
    3027             : 
    3028             : // Test CPLCharUniquePtr
    3029           4 : TEST_F(test_cpl, CPLCharUniquePtr)
    3030             : {
    3031           0 :     CPLCharUniquePtr x;
    3032           1 :     ASSERT_TRUE(x.get() == nullptr);
    3033           1 :     x.reset(CPLStrdup("foo"));
    3034           1 :     ASSERT_STREQ(x.get(), "foo");
    3035             : }
    3036             : 
    3037             : // Test CPLJSonStreamingWriter
    3038           4 : TEST_F(test_cpl, CPLJSonStreamingWriter)
    3039             : {
    3040             :     {
    3041           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3042           2 :         ASSERT_EQ(x.GetString(), std::string());
    3043             :     }
    3044             :     {
    3045           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3046           1 :         x.Add(true);
    3047           2 :         ASSERT_EQ(x.GetString(), std::string("true"));
    3048             :     }
    3049             :     {
    3050           1 :         std::string res;
    3051             : 
    3052             :         struct MyCallback
    3053             :         {
    3054           1 :             static void f(const char *pszText, void *user_data)
    3055             :             {
    3056           1 :                 *static_cast<std::string *>(user_data) += pszText;
    3057           1 :             }
    3058             :         };
    3059             : 
    3060           1 :         CPLJSonStreamingWriter x(&MyCallback::f, &res);
    3061           1 :         x.Add(true);
    3062           2 :         ASSERT_EQ(x.GetString(), std::string());
    3063           2 :         ASSERT_EQ(res, std::string("true"));
    3064             :     }
    3065             :     {
    3066           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3067           1 :         x.Add(false);
    3068           2 :         ASSERT_EQ(x.GetString(), std::string("false"));
    3069             :     }
    3070             :     {
    3071           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3072           1 :         x.AddNull();
    3073           2 :         ASSERT_EQ(x.GetString(), std::string("null"));
    3074             :     }
    3075             :     {
    3076           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3077           1 :         x.Add(1);
    3078           2 :         ASSERT_EQ(x.GetString(), std::string("1"));
    3079             :     }
    3080             :     {
    3081           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3082           1 :         x.Add(4200000000U);
    3083           2 :         ASSERT_EQ(x.GetString(), std::string("4200000000"));
    3084             :     }
    3085             :     {
    3086           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3087           1 :         x.Add(static_cast<std::int64_t>(-10000) * 1000000);
    3088           2 :         ASSERT_EQ(x.GetString(), std::string("-10000000000"));
    3089             :     }
    3090             :     {
    3091           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3092           1 :         x.Add(static_cast<std::uint64_t>(10000) * 1000000);
    3093           2 :         ASSERT_EQ(x.GetString(), std::string("10000000000"));
    3094             :     }
    3095             :     {
    3096           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3097           1 :         x.Add(1.5f);
    3098           2 :         ASSERT_EQ(x.GetString(), std::string("1.5"));
    3099             :     }
    3100             :     {
    3101           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3102           1 :         x.Add(std::numeric_limits<float>::quiet_NaN());
    3103           2 :         ASSERT_EQ(x.GetString(), std::string("\"NaN\""));
    3104             :     }
    3105             :     {
    3106           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3107           1 :         x.Add(std::numeric_limits<float>::infinity());
    3108           2 :         ASSERT_EQ(x.GetString(), std::string("\"Infinity\""));
    3109             :     }
    3110             :     {
    3111           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3112           1 :         x.Add(-std::numeric_limits<float>::infinity());
    3113           2 :         ASSERT_EQ(x.GetString(), std::string("\"-Infinity\""));
    3114             :     }
    3115             :     {
    3116           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3117           1 :         x.Add(1.25);
    3118           2 :         ASSERT_EQ(x.GetString(), std::string("1.25"));
    3119             :     }
    3120             :     {
    3121           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3122           1 :         x.Add(std::numeric_limits<double>::quiet_NaN());
    3123           2 :         ASSERT_EQ(x.GetString(), std::string("\"NaN\""));
    3124             :     }
    3125             :     {
    3126           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3127           1 :         x.Add(std::numeric_limits<double>::infinity());
    3128           2 :         ASSERT_EQ(x.GetString(), std::string("\"Infinity\""));
    3129             :     }
    3130             :     {
    3131           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3132           1 :         x.Add(-std::numeric_limits<double>::infinity());
    3133           2 :         ASSERT_EQ(x.GetString(), std::string("\"-Infinity\""));
    3134             :     }
    3135             :     {
    3136           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3137           1 :         x.Add(std::string("foo\\bar\"baz\b\f\n\r\t"
    3138             :                           "\x01"
    3139             :                           "boo"));
    3140           2 :         ASSERT_EQ(
    3141             :             x.GetString(),
    3142             :             std::string("\"foo\\\\bar\\\"baz\\b\\f\\n\\r\\t\\u0001boo\""));
    3143             :     }
    3144             :     {
    3145           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3146           1 :         x.Add("foo\\bar\"baz\b\f\n\r\t"
    3147             :               "\x01"
    3148             :               "boo");
    3149           2 :         ASSERT_EQ(
    3150             :             x.GetString(),
    3151             :             std::string("\"foo\\\\bar\\\"baz\\b\\f\\n\\r\\t\\u0001boo\""));
    3152             :     }
    3153             :     {
    3154           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3155           1 :         x.SetPrettyFormatting(false);
    3156             :         {
    3157           1 :             auto ctxt(x.MakeObjectContext());
    3158             :         }
    3159           2 :         ASSERT_EQ(x.GetString(), std::string("{}"));
    3160             :     }
    3161             :     {
    3162           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3163             :         {
    3164           1 :             auto ctxt(x.MakeObjectContext());
    3165             :         }
    3166           2 :         ASSERT_EQ(x.GetString(), std::string("{}"));
    3167             :     }
    3168             :     {
    3169           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3170           1 :         x.SetPrettyFormatting(false);
    3171             :         {
    3172           2 :             auto ctxt(x.MakeObjectContext());
    3173           1 :             x.AddObjKey("key");
    3174           1 :             x.Add("value");
    3175             :         }
    3176           2 :         ASSERT_EQ(x.GetString(), std::string("{\"key\":\"value\"}"));
    3177             :     }
    3178             :     {
    3179           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3180             :         {
    3181           2 :             auto ctxt(x.MakeObjectContext());
    3182           1 :             x.AddObjKey("key");
    3183           1 :             x.Add("value");
    3184             :         }
    3185           2 :         ASSERT_EQ(x.GetString(), std::string("{\n  \"key\": \"value\"\n}"));
    3186             :     }
    3187             :     {
    3188           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3189             :         {
    3190           2 :             auto ctxt(x.MakeObjectContext());
    3191           1 :             x.AddObjKey("key");
    3192           1 :             x.Add("value");
    3193           1 :             x.AddObjKey("key2");
    3194           1 :             x.Add("value2");
    3195             :         }
    3196           2 :         ASSERT_EQ(
    3197             :             x.GetString(),
    3198             :             std::string("{\n  \"key\": \"value\",\n  \"key2\": \"value2\"\n}"));
    3199             :     }
    3200             :     {
    3201           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3202             :         {
    3203           1 :             auto ctxt(x.MakeArrayContext());
    3204             :         }
    3205           2 :         ASSERT_EQ(x.GetString(), std::string("[]"));
    3206             :     }
    3207             :     {
    3208           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3209             :         {
    3210           2 :             auto ctxt(x.MakeArrayContext());
    3211           1 :             x.Add(1);
    3212             :         }
    3213           2 :         ASSERT_EQ(x.GetString(), std::string("[\n  1\n]"));
    3214             :     }
    3215             :     {
    3216           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3217             :         {
    3218           2 :             auto ctxt(x.MakeArrayContext());
    3219           1 :             x.Add(1);
    3220           1 :             x.Add(2);
    3221             :         }
    3222           2 :         ASSERT_EQ(x.GetString(), std::string("[\n  1,\n  2\n]"));
    3223             :     }
    3224             :     {
    3225           1 :         CPLJSonStreamingWriter x(nullptr, nullptr);
    3226             :         {
    3227           2 :             auto ctxt(x.MakeArrayContext(true));
    3228           1 :             x.Add(1);
    3229           1 :             x.Add(2);
    3230             :         }
    3231           2 :         ASSERT_EQ(x.GetString(), std::string("[1, 2]"));
    3232             :     }
    3233             : }
    3234             : 
    3235             : // Test CPLWorkerThreadPool
    3236           4 : TEST_F(test_cpl, CPLWorkerThreadPool)
    3237             : {
    3238           1 :     CPLWorkerThreadPool oPool;
    3239           1 :     ASSERT_TRUE(oPool.Setup(2, nullptr, nullptr, false));
    3240             : 
    3241        3000 :     const auto myJob = [](void *pData) { (*static_cast<int *>(pData))++; };
    3242             : 
    3243             :     {
    3244           1 :         std::vector<int> res(1000);
    3245        1001 :         for (int i = 0; i < 1000; i++)
    3246             :         {
    3247        1000 :             res[i] = i;
    3248        1000 :             oPool.SubmitJob(myJob, &res[i]);
    3249             :         }
    3250           1 :         oPool.WaitCompletion();
    3251        1001 :         for (int i = 0; i < 1000; i++)
    3252             :         {
    3253        1000 :             ASSERT_EQ(res[i], i + 1);
    3254             :         }
    3255             :     }
    3256             : 
    3257             :     {
    3258           1 :         std::vector<int> res(1000);
    3259           1 :         std::vector<void *> resPtr(1000);
    3260        1001 :         for (int i = 0; i < 1000; i++)
    3261             :         {
    3262        1000 :             res[i] = i;
    3263        1000 :             resPtr[i] = res.data() + i;
    3264             :         }
    3265           1 :         oPool.SubmitJobs(myJob, resPtr);
    3266           1 :         oPool.WaitEvent();
    3267           1 :         oPool.WaitCompletion();
    3268        1001 :         for (int i = 0; i < 1000; i++)
    3269             :         {
    3270        1000 :             ASSERT_EQ(res[i], i + 1);
    3271             :         }
    3272             :     }
    3273             : 
    3274             :     {
    3275           1 :         auto jobQueue1 = oPool.CreateJobQueue();
    3276           1 :         auto jobQueue2 = oPool.CreateJobQueue();
    3277             : 
    3278           1 :         ASSERT_EQ(jobQueue1->GetPool(), &oPool);
    3279             : 
    3280           1 :         std::vector<int> res(1000);
    3281        1001 :         for (int i = 0; i < 1000; i++)
    3282             :         {
    3283        1000 :             res[i] = i;
    3284        1000 :             if (i % 2)
    3285         500 :                 jobQueue1->SubmitJob(myJob, &res[i]);
    3286             :             else
    3287         500 :                 jobQueue2->SubmitJob(myJob, &res[i]);
    3288             :         }
    3289           1 :         jobQueue1->WaitCompletion();
    3290           1 :         jobQueue2->WaitCompletion();
    3291        1001 :         for (int i = 0; i < 1000; i++)
    3292             :         {
    3293        1000 :             ASSERT_EQ(res[i], i + 1);
    3294             :         }
    3295             :     }
    3296             : }
    3297             : 
    3298             : // Test CPLHTTPFetch
    3299           4 : TEST_F(test_cpl, CPLHTTPFetch)
    3300             : {
    3301             : #ifdef HAVE_CURL
    3302           2 :     CPLStringList oOptions;
    3303           1 :     oOptions.AddNameValue("FORM_ITEM_COUNT", "5");
    3304           1 :     oOptions.AddNameValue("FORM_KEY_0", "qqq");
    3305           1 :     oOptions.AddNameValue("FORM_VALUE_0", "www");
    3306           1 :     CPLHTTPResult *pResult = CPLHTTPFetch("http://example.com", oOptions);
    3307           1 :     EXPECT_EQ(pResult->nStatus, 34);
    3308           1 :     CPLHTTPDestroyResult(pResult);
    3309           1 :     pResult = nullptr;
    3310           1 :     oOptions.Clear();
    3311             : 
    3312           1 :     oOptions.AddNameValue("FORM_FILE_PATH", "not_existed");
    3313           1 :     pResult = CPLHTTPFetch("http://example.com", oOptions);
    3314           1 :     EXPECT_EQ(pResult->nStatus, 34);
    3315           1 :     CPLHTTPDestroyResult(pResult);
    3316             : #else
    3317             :     GTEST_SKIP() << "CURL not available";
    3318             : #endif  // HAVE_CURL
    3319           1 : }
    3320             : 
    3321             : // Test CPLHTTPPushFetchCallback
    3322           4 : TEST_F(test_cpl, CPLHTTPPushFetchCallback)
    3323             : {
    3324             :     struct myCbkUserDataStruct
    3325             :     {
    3326             :         CPLString osURL{};
    3327             :         CSLConstList papszOptions = nullptr;
    3328             :         GDALProgressFunc pfnProgress = nullptr;
    3329             :         void *pProgressArg = nullptr;
    3330             :         CPLHTTPFetchWriteFunc pfnWrite = nullptr;
    3331             :         void *pWriteArg = nullptr;
    3332             :     };
    3333             : 
    3334           1 :     const auto myCbk = [](const char *pszURL, CSLConstList papszOptions,
    3335             :                           GDALProgressFunc pfnProgress, void *pProgressArg,
    3336             :                           CPLHTTPFetchWriteFunc pfnWrite, void *pWriteArg,
    3337             :                           void *pUserData)
    3338             :     {
    3339           1 :         myCbkUserDataStruct *pCbkUserData =
    3340             :             static_cast<myCbkUserDataStruct *>(pUserData);
    3341           1 :         pCbkUserData->osURL = pszURL;
    3342           1 :         pCbkUserData->papszOptions = papszOptions;
    3343           1 :         pCbkUserData->pfnProgress = pfnProgress;
    3344           1 :         pCbkUserData->pProgressArg = pProgressArg;
    3345           1 :         pCbkUserData->pfnWrite = pfnWrite;
    3346           1 :         pCbkUserData->pWriteArg = pWriteArg;
    3347             :         auto psResult =
    3348           1 :             static_cast<CPLHTTPResult *>(CPLCalloc(sizeof(CPLHTTPResult), 1));
    3349           1 :         psResult->nStatus = 123;
    3350           1 :         return psResult;
    3351             :     };
    3352             : 
    3353           1 :     myCbkUserDataStruct userData;
    3354           1 :     EXPECT_TRUE(CPLHTTPPushFetchCallback(myCbk, &userData));
    3355             : 
    3356           1 :     int progressArg = 0;
    3357           0 :     const auto myWriteCbk = [](void *, size_t, size_t, void *) -> size_t
    3358           0 :     { return 0; };
    3359           1 :     int writeCbkArg = 00;
    3360             : 
    3361           1 :     CPLStringList aosOptions;
    3362           1 :     GDALProgressFunc pfnProgress = GDALTermProgress;
    3363           1 :     CPLHTTPFetchWriteFunc pfnWriteCbk = myWriteCbk;
    3364             :     CPLHTTPResult *pResult =
    3365           1 :         CPLHTTPFetchEx("http://example.com", aosOptions.List(), pfnProgress,
    3366             :                        &progressArg, pfnWriteCbk, &writeCbkArg);
    3367           1 :     ASSERT_TRUE(pResult != nullptr);
    3368           1 :     EXPECT_EQ(pResult->nStatus, 123);
    3369           1 :     CPLHTTPDestroyResult(pResult);
    3370             : 
    3371           1 :     EXPECT_TRUE(CPLHTTPPopFetchCallback());
    3372           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    3373           1 :     EXPECT_TRUE(!CPLHTTPPopFetchCallback());
    3374           1 :     CPLPopErrorHandler();
    3375             : 
    3376           1 :     EXPECT_STREQ(userData.osURL, "http://example.com");
    3377           1 :     EXPECT_EQ(userData.papszOptions, aosOptions.List());
    3378           1 :     EXPECT_EQ(userData.pfnProgress, pfnProgress);
    3379           1 :     EXPECT_EQ(userData.pProgressArg, &progressArg);
    3380           1 :     EXPECT_EQ(userData.pfnWrite, pfnWriteCbk);
    3381           1 :     EXPECT_EQ(userData.pWriteArg, &writeCbkArg);
    3382             : }
    3383             : 
    3384             : // Test CPLHTTPSetFetchCallback
    3385           4 : TEST_F(test_cpl, CPLHTTPSetFetchCallback)
    3386             : {
    3387             :     struct myCbkUserDataStruct
    3388             :     {
    3389             :         CPLString osURL{};
    3390             :         CSLConstList papszOptions = nullptr;
    3391             :         GDALProgressFunc pfnProgress = nullptr;
    3392             :         void *pProgressArg = nullptr;
    3393             :         CPLHTTPFetchWriteFunc pfnWrite = nullptr;
    3394             :         void *pWriteArg = nullptr;
    3395             :     };
    3396             : 
    3397           1 :     const auto myCbk2 = [](const char *pszURL, CSLConstList papszOptions,
    3398             :                            GDALProgressFunc pfnProgress, void *pProgressArg,
    3399             :                            CPLHTTPFetchWriteFunc pfnWrite, void *pWriteArg,
    3400             :                            void *pUserData)
    3401             :     {
    3402           1 :         myCbkUserDataStruct *pCbkUserData =
    3403             :             static_cast<myCbkUserDataStruct *>(pUserData);
    3404           1 :         pCbkUserData->osURL = pszURL;
    3405           1 :         pCbkUserData->papszOptions = papszOptions;
    3406           1 :         pCbkUserData->pfnProgress = pfnProgress;
    3407           1 :         pCbkUserData->pProgressArg = pProgressArg;
    3408           1 :         pCbkUserData->pfnWrite = pfnWrite;
    3409           1 :         pCbkUserData->pWriteArg = pWriteArg;
    3410             :         auto psResult =
    3411           1 :             static_cast<CPLHTTPResult *>(CPLCalloc(sizeof(CPLHTTPResult), 1));
    3412           1 :         psResult->nStatus = 124;
    3413           1 :         return psResult;
    3414             :     };
    3415           1 :     myCbkUserDataStruct userData2;
    3416           1 :     CPLHTTPSetFetchCallback(myCbk2, &userData2);
    3417             : 
    3418           1 :     int progressArg = 0;
    3419           0 :     const auto myWriteCbk = [](void *, size_t, size_t, void *) -> size_t
    3420           0 :     { return 0; };
    3421           1 :     int writeCbkArg = 00;
    3422             : 
    3423           1 :     CPLStringList aosOptions;
    3424           1 :     GDALProgressFunc pfnProgress = GDALTermProgress;
    3425           1 :     CPLHTTPFetchWriteFunc pfnWriteCbk = myWriteCbk;
    3426             :     CPLHTTPResult *pResult =
    3427           1 :         CPLHTTPFetchEx("http://example.com", aosOptions.List(), pfnProgress,
    3428             :                        &progressArg, pfnWriteCbk, &writeCbkArg);
    3429           1 :     ASSERT_TRUE(pResult != nullptr);
    3430           1 :     EXPECT_EQ(pResult->nStatus, 124);
    3431           1 :     CPLHTTPDestroyResult(pResult);
    3432             : 
    3433           1 :     CPLHTTPSetFetchCallback(nullptr, nullptr);
    3434             : 
    3435           1 :     EXPECT_STREQ(userData2.osURL, "http://example.com");
    3436           1 :     EXPECT_EQ(userData2.papszOptions, aosOptions.List());
    3437           1 :     EXPECT_EQ(userData2.pfnProgress, pfnProgress);
    3438           1 :     EXPECT_EQ(userData2.pProgressArg, &progressArg);
    3439           1 :     EXPECT_EQ(userData2.pfnWrite, pfnWriteCbk);
    3440           1 :     EXPECT_EQ(userData2.pWriteArg, &writeCbkArg);
    3441             : }
    3442             : 
    3443             : // Test CPLLoadConfigOptionsFromFile() and
    3444             : // CPLLoadConfigOptionsFromPredefinedFiles()
    3445           4 : TEST_F(test_cpl, CPLLoadConfigOptionsFromFile)
    3446             : {
    3447           1 :     CPLLoadConfigOptionsFromFile("/i/do/not/exist", false);
    3448             : 
    3449           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/.gdal/gdalrc", "wb");
    3450           1 :     VSIFPrintfL(fp, "# some comment\n");
    3451           1 :     VSIFPrintfL(fp, "\n");    // blank line
    3452           1 :     VSIFPrintfL(fp, "  \n");  // blank line
    3453           1 :     VSIFPrintfL(fp, "[configoptions]\n");
    3454           1 :     VSIFPrintfL(fp, "# some comment\n");
    3455           1 :     VSIFPrintfL(fp, "FOO_CONFIGOPTION=BAR\n");
    3456           1 :     VSIFCloseL(fp);
    3457             : 
    3458             :     // Try CPLLoadConfigOptionsFromFile()
    3459           1 :     CPLLoadConfigOptionsFromFile("/vsimem/.gdal/gdalrc", false);
    3460           1 :     ASSERT_TRUE(EQUAL(CPLGetConfigOption("FOO_CONFIGOPTION", ""), "BAR"));
    3461           1 :     CPLSetConfigOption("FOO_CONFIGOPTION", nullptr);
    3462             : 
    3463             :     // Try CPLLoadConfigOptionsFromPredefinedFiles() with GDAL_CONFIG_FILE set
    3464           1 :     CPLSetConfigOption("GDAL_CONFIG_FILE", "/vsimem/.gdal/gdalrc");
    3465           1 :     CPLLoadConfigOptionsFromPredefinedFiles();
    3466           1 :     ASSERT_TRUE(EQUAL(CPLGetConfigOption("FOO_CONFIGOPTION", ""), "BAR"));
    3467           1 :     CPLSetConfigOption("FOO_CONFIGOPTION", nullptr);
    3468             : 
    3469             :     // Try CPLLoadConfigOptionsFromPredefinedFiles() with $HOME/.gdal/gdalrc
    3470             :     // file
    3471             : #ifdef _WIN32
    3472             :     const char *pszHOMEEnvVarName = "USERPROFILE";
    3473             : #else
    3474           1 :     const char *pszHOMEEnvVarName = "HOME";
    3475             : #endif
    3476           1 :     CPLString osOldVal(CPLGetConfigOption(pszHOMEEnvVarName, ""));
    3477           1 :     CPLSetConfigOption(pszHOMEEnvVarName, "/vsimem/");
    3478           1 :     CPLLoadConfigOptionsFromPredefinedFiles();
    3479           1 :     ASSERT_TRUE(EQUAL(CPLGetConfigOption("FOO_CONFIGOPTION", ""), "BAR"));
    3480           1 :     CPLSetConfigOption("FOO_CONFIGOPTION", nullptr);
    3481           1 :     if (!osOldVal.empty())
    3482           1 :         CPLSetConfigOption(pszHOMEEnvVarName, osOldVal.c_str());
    3483             :     else
    3484           0 :         CPLSetConfigOption(pszHOMEEnvVarName, nullptr);
    3485             : 
    3486           1 :     VSIUnlink("/vsimem/.gdal/gdalrc");
    3487             : }
    3488             : 
    3489             : // Test decompressor side of cpl_compressor.h
    3490           4 : TEST_F(test_cpl, decompressor)
    3491             : {
    3492             :     const auto compressionLambda =
    3493           0 :         [](const void * /* input_data */, size_t /* input_size */,
    3494             :            void ** /* output_data */, size_t * /* output_size */,
    3495             :            CSLConstList /* options */, void * /* compressor_user_data */)
    3496           0 :     { return false; };
    3497           1 :     int dummy = 0;
    3498             : 
    3499             :     CPLCompressor sComp;
    3500           1 :     sComp.nStructVersion = 1;
    3501           1 :     sComp.eType = CCT_COMPRESSOR;
    3502           1 :     sComp.pszId = "my_comp";
    3503           1 :     const char *const apszMetadata[] = {"FOO=BAR", nullptr};
    3504           1 :     sComp.papszMetadata = apszMetadata;
    3505           1 :     sComp.pfnFunc = compressionLambda;
    3506           1 :     sComp.user_data = &dummy;
    3507             : 
    3508           1 :     ASSERT_TRUE(CPLRegisterDecompressor(&sComp));
    3509             : 
    3510           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    3511           1 :     ASSERT_TRUE(!CPLRegisterDecompressor(&sComp));
    3512           1 :     CPLPopErrorHandler();
    3513             : 
    3514           1 :     char **decompressors = CPLGetDecompressors();
    3515           1 :     ASSERT_TRUE(decompressors != nullptr);
    3516           1 :     EXPECT_TRUE(CSLFindString(decompressors, sComp.pszId) >= 0);
    3517           9 :     for (auto iter = decompressors; *iter; ++iter)
    3518             :     {
    3519           8 :         const auto pCompressor = CPLGetDecompressor(*iter);
    3520           8 :         EXPECT_TRUE(pCompressor);
    3521           8 :         if (pCompressor)
    3522             :         {
    3523             :             const char *pszOptions =
    3524           8 :                 CSLFetchNameValue(pCompressor->papszMetadata, "OPTIONS");
    3525           8 :             if (pszOptions)
    3526             :             {
    3527           3 :                 auto psNode = CPLParseXMLString(pszOptions);
    3528           3 :                 EXPECT_TRUE(psNode);
    3529           3 :                 CPLDestroyXMLNode(psNode);
    3530             :             }
    3531             :             else
    3532             :             {
    3533           5 :                 CPLDebug("TEST", "Decompressor %s has no OPTIONS", *iter);
    3534             :             }
    3535             :         }
    3536             :     }
    3537           1 :     CSLDestroy(decompressors);
    3538             : 
    3539           1 :     EXPECT_TRUE(CPLGetDecompressor("invalid") == nullptr);
    3540           1 :     const auto pCompressor = CPLGetDecompressor(sComp.pszId);
    3541           1 :     ASSERT_TRUE(pCompressor);
    3542           1 :     EXPECT_STREQ(pCompressor->pszId, sComp.pszId);
    3543           1 :     EXPECT_EQ(CSLCount(pCompressor->papszMetadata),
    3544             :               CSLCount(sComp.papszMetadata));
    3545           1 :     EXPECT_TRUE(pCompressor->pfnFunc != nullptr);
    3546           1 :     EXPECT_EQ(pCompressor->user_data, sComp.user_data);
    3547             : 
    3548           1 :     CPLDestroyCompressorRegistry();
    3549           1 :     EXPECT_TRUE(CPLGetDecompressor(sComp.pszId) == nullptr);
    3550             : }
    3551             : 
    3552             : // Test compressor side of cpl_compressor.h
    3553           4 : TEST_F(test_cpl, compressor)
    3554             : {
    3555             :     const auto compressionLambda =
    3556           0 :         [](const void * /* input_data */, size_t /* input_size */,
    3557             :            void ** /* output_data */, size_t * /* output_size */,
    3558             :            CSLConstList /* options */, void * /* compressor_user_data */)
    3559           0 :     { return false; };
    3560           1 :     int dummy = 0;
    3561             : 
    3562             :     CPLCompressor sComp;
    3563           1 :     sComp.nStructVersion = 1;
    3564           1 :     sComp.eType = CCT_COMPRESSOR;
    3565           1 :     sComp.pszId = "my_comp";
    3566           1 :     const char *const apszMetadata[] = {"FOO=BAR", nullptr};
    3567           1 :     sComp.papszMetadata = apszMetadata;
    3568           1 :     sComp.pfnFunc = compressionLambda;
    3569           1 :     sComp.user_data = &dummy;
    3570             : 
    3571           1 :     ASSERT_TRUE(CPLRegisterCompressor(&sComp));
    3572             : 
    3573           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    3574           1 :     ASSERT_TRUE(!CPLRegisterCompressor(&sComp));
    3575           1 :     CPLPopErrorHandler();
    3576             : 
    3577           1 :     char **compressors = CPLGetCompressors();
    3578           1 :     ASSERT_TRUE(compressors != nullptr);
    3579           1 :     EXPECT_TRUE(CSLFindString(compressors, sComp.pszId) >= 0);
    3580           9 :     for (auto iter = compressors; *iter; ++iter)
    3581             :     {
    3582           8 :         const auto pCompressor = CPLGetCompressor(*iter);
    3583           8 :         EXPECT_TRUE(pCompressor);
    3584           8 :         if (pCompressor)
    3585             :         {
    3586             :             const char *pszOptions =
    3587           8 :                 CSLFetchNameValue(pCompressor->papszMetadata, "OPTIONS");
    3588           8 :             if (pszOptions)
    3589             :             {
    3590           7 :                 auto psNode = CPLParseXMLString(pszOptions);
    3591           7 :                 EXPECT_TRUE(psNode);
    3592           7 :                 CPLDestroyXMLNode(psNode);
    3593             :             }
    3594             :             else
    3595             :             {
    3596           1 :                 CPLDebug("TEST", "Compressor %s has no OPTIONS", *iter);
    3597             :             }
    3598             :         }
    3599             :     }
    3600           1 :     CSLDestroy(compressors);
    3601             : 
    3602           1 :     EXPECT_TRUE(CPLGetCompressor("invalid") == nullptr);
    3603           1 :     const auto pCompressor = CPLGetCompressor(sComp.pszId);
    3604           1 :     ASSERT_TRUE(pCompressor);
    3605           1 :     if (pCompressor == nullptr)
    3606           0 :         return;
    3607           1 :     EXPECT_STREQ(pCompressor->pszId, sComp.pszId);
    3608           1 :     EXPECT_EQ(CSLCount(pCompressor->papszMetadata),
    3609             :               CSLCount(sComp.papszMetadata));
    3610           1 :     EXPECT_TRUE(pCompressor->pfnFunc != nullptr);
    3611           1 :     EXPECT_EQ(pCompressor->user_data, sComp.user_data);
    3612             : 
    3613           1 :     CPLDestroyCompressorRegistry();
    3614           1 :     EXPECT_TRUE(CPLGetDecompressor(sComp.pszId) == nullptr);
    3615             : }
    3616             : 
    3617             : // Test builtin compressors/decompressor
    3618           4 : TEST_F(test_cpl, builtin_compressors)
    3619             : {
    3620           7 :     for (const char *id : {"blosc", "zlib", "gzip", "lzma", "zstd", "lz4"})
    3621             :     {
    3622           6 :         const auto pCompressor = CPLGetCompressor(id);
    3623           6 :         if (pCompressor == nullptr)
    3624             :         {
    3625           0 :             CPLDebug("TEST", "%s not available", id);
    3626           0 :             if (strcmp(id, "zlib") == 0 || strcmp(id, "gzip") == 0)
    3627             :             {
    3628           0 :                 ASSERT_TRUE(false);
    3629             :             }
    3630           0 :             continue;
    3631             :         }
    3632           6 :         CPLDebug("TEST", "Testing %s", id);
    3633             : 
    3634           6 :         const char my_str[] = "my string to compress";
    3635           6 :         const char *const options[] = {"TYPESIZE=1", nullptr};
    3636             : 
    3637             :         // Compressor side
    3638             : 
    3639             :         // Just get output size
    3640           6 :         size_t out_size = 0;
    3641           6 :         ASSERT_TRUE(pCompressor->pfnFunc(my_str, strlen(my_str), nullptr,
    3642             :                                          &out_size, options,
    3643             :                                          pCompressor->user_data));
    3644           6 :         ASSERT_TRUE(out_size != 0);
    3645             : 
    3646             :         // Let it alloc the output buffer
    3647           6 :         void *out_buffer2 = nullptr;
    3648           6 :         size_t out_size2 = 0;
    3649           6 :         ASSERT_TRUE(pCompressor->pfnFunc(my_str, strlen(my_str), &out_buffer2,
    3650             :                                          &out_size2, options,
    3651             :                                          pCompressor->user_data));
    3652           6 :         ASSERT_TRUE(out_buffer2 != nullptr);
    3653           6 :         ASSERT_TRUE(out_size2 != 0);
    3654           6 :         ASSERT_TRUE(out_size2 <= out_size);
    3655             : 
    3656           6 :         std::vector<GByte> out_buffer3(out_size);
    3657             : 
    3658             :         // Provide not large enough buffer size
    3659           6 :         size_t out_size3 = 1;
    3660           6 :         void *out_buffer3_ptr = &out_buffer3[0];
    3661           6 :         ASSERT_TRUE(!(pCompressor->pfnFunc(my_str, strlen(my_str),
    3662             :                                            &out_buffer3_ptr, &out_size3,
    3663             :                                            options, pCompressor->user_data)));
    3664             : 
    3665             :         // Provide the output buffer
    3666           6 :         out_size3 = out_buffer3.size();
    3667           6 :         out_buffer3_ptr = &out_buffer3[0];
    3668           6 :         ASSERT_TRUE(pCompressor->pfnFunc(my_str, strlen(my_str),
    3669             :                                          &out_buffer3_ptr, &out_size3, options,
    3670             :                                          pCompressor->user_data));
    3671           6 :         ASSERT_TRUE(out_buffer3_ptr != nullptr);
    3672           6 :         ASSERT_TRUE(out_buffer3_ptr == &out_buffer3[0]);
    3673           6 :         ASSERT_TRUE(out_size3 != 0);
    3674           6 :         ASSERT_EQ(out_size3, out_size2);
    3675             : 
    3676           6 :         out_buffer3.resize(out_size3);
    3677           6 :         out_buffer3_ptr = &out_buffer3[0];
    3678             : 
    3679           6 :         ASSERT_TRUE(memcmp(out_buffer3_ptr, out_buffer2, out_size2) == 0);
    3680             : 
    3681           6 :         CPLFree(out_buffer2);
    3682             : 
    3683           6 :         const std::vector<GByte> compressedData(out_buffer3);
    3684             : 
    3685             :         // Decompressor side
    3686           6 :         const auto pDecompressor = CPLGetDecompressor(id);
    3687           6 :         ASSERT_TRUE(pDecompressor != nullptr);
    3688             : 
    3689           6 :         out_size = 0;
    3690           6 :         ASSERT_TRUE(pDecompressor->pfnFunc(
    3691             :             compressedData.data(), compressedData.size(), nullptr, &out_size,
    3692             :             nullptr, pDecompressor->user_data));
    3693           6 :         ASSERT_TRUE(out_size != 0);
    3694           6 :         ASSERT_TRUE(out_size >= strlen(my_str));
    3695             : 
    3696           6 :         out_buffer2 = nullptr;
    3697           6 :         out_size2 = 0;
    3698           6 :         ASSERT_TRUE(pDecompressor->pfnFunc(
    3699             :             compressedData.data(), compressedData.size(), &out_buffer2,
    3700             :             &out_size2, options, pDecompressor->user_data));
    3701           6 :         ASSERT_TRUE(out_buffer2 != nullptr);
    3702           6 :         ASSERT_TRUE(out_size2 != 0);
    3703           6 :         ASSERT_EQ(out_size2, strlen(my_str));
    3704           6 :         ASSERT_TRUE(memcmp(out_buffer2, my_str, strlen(my_str)) == 0);
    3705           6 :         CPLFree(out_buffer2);
    3706             : 
    3707           6 :         out_buffer3.clear();
    3708           6 :         out_buffer3.resize(out_size);
    3709           6 :         out_size3 = out_buffer3.size();
    3710           6 :         out_buffer3_ptr = &out_buffer3[0];
    3711           6 :         ASSERT_TRUE(pDecompressor->pfnFunc(
    3712             :             compressedData.data(), compressedData.size(), &out_buffer3_ptr,
    3713             :             &out_size3, options, pDecompressor->user_data));
    3714           6 :         ASSERT_TRUE(out_buffer3_ptr != nullptr);
    3715           6 :         ASSERT_TRUE(out_buffer3_ptr == &out_buffer3[0]);
    3716           6 :         ASSERT_EQ(out_size3, strlen(my_str));
    3717           6 :         ASSERT_TRUE(memcmp(out_buffer3.data(), my_str, strlen(my_str)) == 0);
    3718             :     }
    3719             : }
    3720             : 
    3721             : // Test builtin compressors/decompressor
    3722           4 : TEST_F(test_cpl, builtin_compressors_zlib_high_compression_rate)
    3723             : {
    3724           1 :     const auto pCompressor = CPLGetCompressor("zlib");
    3725           1 :     ASSERT_TRUE(pCompressor != nullptr);
    3726             : 
    3727           1 :     std::vector<GByte> abyInput(1024 * 1024, 0x01);
    3728             : 
    3729             :     // Compressor side
    3730             : 
    3731             :     // Let it alloc the output buffer
    3732           1 :     void *out_buffer = nullptr;
    3733           1 :     size_t out_size = 0;
    3734           1 :     ASSERT_TRUE(pCompressor->pfnFunc(abyInput.data(), abyInput.size(),
    3735             :                                      &out_buffer, &out_size, nullptr,
    3736             :                                      pCompressor->user_data));
    3737           1 :     ASSERT_TRUE(out_buffer != nullptr);
    3738           1 :     ASSERT_TRUE(out_size != 0);
    3739             : 
    3740             :     // Decompressor side
    3741           1 :     const auto pDecompressor = CPLGetDecompressor("zlib");
    3742           1 :     ASSERT_TRUE(pDecompressor != nullptr);
    3743             : 
    3744           1 :     void *out_buffer2 = nullptr;
    3745           1 :     size_t out_size2 = 0;
    3746           1 :     ASSERT_TRUE(pDecompressor->pfnFunc(out_buffer, out_size, &out_buffer2,
    3747             :                                        &out_size2, nullptr,
    3748             :                                        pDecompressor->user_data));
    3749           1 :     CPLFree(out_buffer);
    3750             : 
    3751           1 :     ASSERT_TRUE(out_buffer2 != nullptr);
    3752           1 :     ASSERT_TRUE(out_size2 != 0);
    3753           1 :     ASSERT_EQ(out_size2, abyInput.size());
    3754           1 :     ASSERT_TRUE(memcmp(out_buffer2, abyInput.data(), abyInput.size()) == 0);
    3755           1 :     CPLFree(out_buffer2);
    3756             : }
    3757             : 
    3758             : template <class T> struct TesterDelta
    3759             : {
    3760          24 :     static void test(const char *dtypeOption)
    3761             :     {
    3762          24 :         const auto pCompressor = CPLGetCompressor("delta");
    3763          24 :         ASSERT_TRUE(pCompressor);
    3764          24 :         if (pCompressor == nullptr)
    3765           0 :             return;
    3766          24 :         const auto pDecompressor = CPLGetDecompressor("delta");
    3767          24 :         ASSERT_TRUE(pDecompressor);
    3768          24 :         if (pDecompressor == nullptr)
    3769           0 :             return;
    3770             : 
    3771          24 :         const T tabIn[] = {static_cast<T>(-2), 3, 1};
    3772             :         T tabCompress[3];
    3773             :         T tabOut[3];
    3774          24 :         const char *const apszOptions[] = {dtypeOption, nullptr};
    3775             : 
    3776          24 :         void *outPtr = &tabCompress[0];
    3777          24 :         size_t outSize = sizeof(tabCompress);
    3778          24 :         ASSERT_TRUE(pCompressor->pfnFunc(&tabIn[0], sizeof(tabIn), &outPtr,
    3779             :                                          &outSize, apszOptions,
    3780             :                                          pCompressor->user_data));
    3781          24 :         ASSERT_EQ(outSize, sizeof(tabCompress));
    3782             : 
    3783             :         // ASSERT_EQ(tabCompress[0], 2);
    3784             :         // ASSERT_EQ(tabCompress[1], 1);
    3785             :         // ASSERT_EQ(tabCompress[2], -2);
    3786             : 
    3787          24 :         outPtr = &tabOut[0];
    3788          24 :         outSize = sizeof(tabOut);
    3789          24 :         ASSERT_TRUE(pDecompressor->pfnFunc(&tabCompress[0], sizeof(tabCompress),
    3790             :                                            &outPtr, &outSize, apszOptions,
    3791             :                                            pDecompressor->user_data));
    3792          24 :         ASSERT_EQ(outSize, sizeof(tabOut));
    3793          24 :         ASSERT_EQ(tabOut[0], tabIn[0]);
    3794          24 :         ASSERT_EQ(tabOut[1], tabIn[1]);
    3795          24 :         ASSERT_EQ(tabOut[2], tabIn[2]);
    3796             :     }
    3797             : };
    3798             : 
    3799             : // Test delta compressor/decompressor
    3800           4 : TEST_F(test_cpl, delta_compressor)
    3801             : {
    3802           1 :     TesterDelta<int8_t>::test("DTYPE=i1");
    3803             : 
    3804           1 :     TesterDelta<uint8_t>::test("DTYPE=u1");
    3805             : 
    3806           1 :     TesterDelta<int16_t>::test("DTYPE=i2");
    3807           1 :     TesterDelta<int16_t>::test("DTYPE=<i2");
    3808           1 :     TesterDelta<int16_t>::test("DTYPE=>i2");
    3809             : 
    3810           1 :     TesterDelta<uint16_t>::test("DTYPE=u2");
    3811           1 :     TesterDelta<uint16_t>::test("DTYPE=<u2");
    3812           1 :     TesterDelta<uint16_t>::test("DTYPE=>u2");
    3813             : 
    3814           1 :     TesterDelta<int32_t>::test("DTYPE=i4");
    3815           1 :     TesterDelta<int32_t>::test("DTYPE=<i4");
    3816           1 :     TesterDelta<int32_t>::test("DTYPE=>i4");
    3817             : 
    3818           1 :     TesterDelta<uint32_t>::test("DTYPE=u4");
    3819           1 :     TesterDelta<uint32_t>::test("DTYPE=<u4");
    3820           1 :     TesterDelta<uint32_t>::test("DTYPE=>u4");
    3821             : 
    3822           1 :     TesterDelta<int64_t>::test("DTYPE=i8");
    3823           1 :     TesterDelta<int64_t>::test("DTYPE=<i8");
    3824           1 :     TesterDelta<int64_t>::test("DTYPE=>i8");
    3825             : 
    3826           1 :     TesterDelta<uint64_t>::test("DTYPE=u8");
    3827           1 :     TesterDelta<uint64_t>::test("DTYPE=<u8");
    3828           1 :     TesterDelta<uint64_t>::test("DTYPE=>u8");
    3829             : 
    3830           1 :     TesterDelta<float>::test("DTYPE=f4");
    3831             : #ifdef CPL_MSB
    3832             :     TesterDelta<float>::test("DTYPE=>f4");
    3833             : #else
    3834           1 :     TesterDelta<float>::test("DTYPE=<f4");
    3835             : #endif
    3836             : 
    3837           1 :     TesterDelta<double>::test("DTYPE=f8");
    3838             : #ifdef CPL_MSB
    3839             :     TesterDelta<double>::test("DTYPE=>f8");
    3840             : #else
    3841           1 :     TesterDelta<double>::test("DTYPE=<f8");
    3842             : #endif
    3843           1 : }
    3844             : 
    3845             : // Test CPLQuadTree
    3846           4 : TEST_F(test_cpl, CPLQuadTree)
    3847             : {
    3848           1 :     unsigned next = 0;
    3849             : 
    3850           4 :     const auto DummyRandInit = [&next](unsigned initValue)
    3851           5 :     { next = initValue; };
    3852             : 
    3853           1 :     constexpr int MAX_RAND_VAL = 32767;
    3854             : 
    3855             :     // Slightly improved version of https://xkcd.com/221/, as suggested by
    3856             :     // "man srand"
    3857       16000 :     const auto DummyRand = [&]()
    3858             :     {
    3859       16000 :         next = next * 1103515245 + 12345;
    3860       16000 :         return ((unsigned)(next / 65536) % (MAX_RAND_VAL + 1));
    3861           1 :     };
    3862             : 
    3863             :     CPLRectObj globalbounds;
    3864           1 :     globalbounds.minx = 0;
    3865           1 :     globalbounds.miny = 0;
    3866           1 :     globalbounds.maxx = 1;
    3867           1 :     globalbounds.maxy = 1;
    3868             : 
    3869           1 :     auto hTree = CPLQuadTreeCreate(&globalbounds, nullptr);
    3870           1 :     ASSERT_TRUE(hTree != nullptr);
    3871             : 
    3872        4000 :     const auto GenerateRandomRect = [&](CPLRectObj &rect)
    3873             :     {
    3874        4000 :         rect.minx = double(DummyRand()) / MAX_RAND_VAL;
    3875        4000 :         rect.miny = double(DummyRand()) / MAX_RAND_VAL;
    3876        4000 :         rect.maxx =
    3877        4000 :             rect.minx + double(DummyRand()) / MAX_RAND_VAL * (1 - rect.minx);
    3878        4000 :         rect.maxy =
    3879        4000 :             rect.miny + double(DummyRand()) / MAX_RAND_VAL * (1 - rect.miny);
    3880        4001 :     };
    3881             : 
    3882           3 :     for (int j = 0; j < 2; j++)
    3883             :     {
    3884           2 :         DummyRandInit(j);
    3885        2002 :         for (int i = 0; i < 1000; i++)
    3886             :         {
    3887             :             CPLRectObj rect;
    3888        2000 :             GenerateRandomRect(rect);
    3889        2000 :             void *hFeature =
    3890        2000 :                 reinterpret_cast<void *>(static_cast<uintptr_t>(i));
    3891        2000 :             CPLQuadTreeInsertWithBounds(hTree, hFeature, &rect);
    3892             :         }
    3893             : 
    3894             :         {
    3895           2 :             int nFeatureCount = 0;
    3896           2 :             CPLFree(CPLQuadTreeSearch(hTree, &globalbounds, &nFeatureCount));
    3897           2 :             ASSERT_EQ(nFeatureCount, 1000);
    3898             :         }
    3899             : 
    3900           2 :         DummyRandInit(j);
    3901        2002 :         for (int i = 0; i < 1000; i++)
    3902             :         {
    3903             :             CPLRectObj rect;
    3904        2000 :             GenerateRandomRect(rect);
    3905        2000 :             void *hFeature =
    3906        2000 :                 reinterpret_cast<void *>(static_cast<uintptr_t>(i));
    3907        2000 :             CPLQuadTreeRemove(hTree, hFeature, &rect);
    3908             :         }
    3909             : 
    3910             :         {
    3911           2 :             int nFeatureCount = 0;
    3912           2 :             CPLFree(CPLQuadTreeSearch(hTree, &globalbounds, &nFeatureCount));
    3913           2 :             ASSERT_EQ(nFeatureCount, 0);
    3914             :         }
    3915             :     }
    3916             : 
    3917           1 :     CPLQuadTreeDestroy(hTree);
    3918             : }
    3919             : 
    3920             : // Test bUnlinkAndSize on VSIGetMemFileBuffer
    3921           4 : TEST_F(test_cpl, VSIGetMemFileBuffer_unlink_and_size)
    3922             : {
    3923             :     VSIVirtualHandleUniquePtr fp(
    3924           1 :         VSIFOpenL("/vsimem/test_unlink_and_seize.tif", "wb"));
    3925           1 :     VSIFWriteL("test", 5, 1, fp.get());
    3926             :     std::unique_ptr<GByte, VSIFreeReleaser> pRawData(VSIGetMemFileBuffer(
    3927           1 :         "/vsimem/test_unlink_and_seize.tif", nullptr, true));
    3928           1 :     ASSERT_TRUE(EQUAL(reinterpret_cast<const char *>(pRawData.get()), "test"));
    3929           1 :     ASSERT_TRUE(VSIGetMemFileBuffer("/vsimem/test_unlink_and_seize.tif",
    3930             :                                     nullptr, false) == nullptr);
    3931             :     VSIVirtualHandleUniquePtr fp2(
    3932           1 :         VSIFOpenL("/vsimem/test_unlink_and_seize.tif", "r"));
    3933           1 :     ASSERT_TRUE(fp2.get() == nullptr);
    3934           1 :     ASSERT_TRUE(VSIFReadL(pRawData.get(), 5, 1, fp.get()) == 0);
    3935           1 :     ASSERT_TRUE(VSIFWriteL(pRawData.get(), 5, 1, fp.get()) == 0);
    3936           1 :     ASSERT_TRUE(VSIFSeekL(fp.get(), 0, SEEK_END) == 0);
    3937             : }
    3938             : 
    3939             : // Test CPLLoadConfigOptionsFromFile() for VSI credentials
    3940           4 : TEST_F(test_cpl, CPLLoadConfigOptionsFromFile_VSI_credentials)
    3941             : {
    3942           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/credentials.txt", "wb");
    3943           1 :     VSIFPrintfL(fp, "[credentials]\n");
    3944           1 :     VSIFPrintfL(fp, "\n");
    3945           1 :     VSIFPrintfL(fp, "[.my_subsection]\n");
    3946           1 :     VSIFPrintfL(fp, "path=/vsi_test/foo/bar\n");
    3947           1 :     VSIFPrintfL(fp, "FOO=BAR\n");
    3948           1 :     VSIFPrintfL(fp, "FOO2=BAR2\n");
    3949           1 :     VSIFPrintfL(fp, "\n");
    3950           1 :     VSIFPrintfL(fp, "[.my_subsection2]\n");
    3951           1 :     VSIFPrintfL(fp, "path=/vsi_test/bar/baz\n");
    3952           1 :     VSIFPrintfL(fp, "BAR=BAZ\n");
    3953           1 :     VSIFPrintfL(fp, "[configoptions]\n");
    3954           1 :     VSIFPrintfL(fp, "configoptions_FOO=BAR\n");
    3955           1 :     VSIFCloseL(fp);
    3956             : 
    3957           1 :     CPLErrorReset();
    3958           1 :     CPLLoadConfigOptionsFromFile("/vsimem/credentials.txt", false);
    3959           1 :     ASSERT_EQ(CPLGetLastErrorType(), CE_None);
    3960             : 
    3961             :     {
    3962             :         const char *pszVal =
    3963           1 :             VSIGetPathSpecificOption("/vsi_test/foo/bar", "FOO", nullptr);
    3964           1 :         ASSERT_TRUE(pszVal != nullptr);
    3965           2 :         ASSERT_EQ(std::string(pszVal), std::string("BAR"));
    3966             :     }
    3967             : 
    3968             :     {
    3969             :         const char *pszVal =
    3970           1 :             VSIGetPathSpecificOption("/vsi_test/foo/bar", "FOO2", nullptr);
    3971           1 :         ASSERT_TRUE(pszVal != nullptr);
    3972           2 :         ASSERT_EQ(std::string(pszVal), std::string("BAR2"));
    3973             :     }
    3974             : 
    3975             :     {
    3976             :         const char *pszVal =
    3977           1 :             VSIGetPathSpecificOption("/vsi_test/bar/baz", "BAR", nullptr);
    3978           1 :         ASSERT_TRUE(pszVal != nullptr);
    3979           2 :         ASSERT_EQ(std::string(pszVal), std::string("BAZ"));
    3980             :     }
    3981             : 
    3982             :     {
    3983           1 :         const char *pszVal = CPLGetConfigOption("configoptions_FOO", nullptr);
    3984           1 :         ASSERT_TRUE(pszVal != nullptr);
    3985           2 :         ASSERT_EQ(std::string(pszVal), std::string("BAR"));
    3986             :     }
    3987             : 
    3988           1 :     VSIClearPathSpecificOptions("/vsi_test/bar/baz");
    3989           1 :     CPLSetConfigOption("configoptions_FOO", nullptr);
    3990             : 
    3991             :     {
    3992             :         const char *pszVal =
    3993           1 :             VSIGetPathSpecificOption("/vsi_test/bar/baz", "BAR", nullptr);
    3994           1 :         ASSERT_TRUE(pszVal == nullptr);
    3995             :     }
    3996             : 
    3997           1 :     VSIUnlink("/vsimem/credentials.txt");
    3998             : }
    3999             : 
    4000             : // Test CPLLoadConfigOptionsFromFile() for VSI credentials, warning case
    4001           4 : TEST_F(test_cpl, CPLLoadConfigOptionsFromFile_VSI_credentials_warning)
    4002             : {
    4003           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/credentials.txt", "wb");
    4004           1 :     VSIFPrintfL(fp, "[credentials]\n");
    4005           1 :     VSIFPrintfL(fp, "\n");
    4006           1 :     VSIFPrintfL(fp, "FOO=BAR\n");  // content outside of subsection
    4007           1 :     VSIFCloseL(fp);
    4008             : 
    4009           1 :     CPLErrorReset();
    4010           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    4011           1 :     CPLLoadConfigOptionsFromFile("/vsimem/credentials.txt", false);
    4012           1 :     CPLPopErrorHandler();
    4013           1 :     ASSERT_EQ(CPLGetLastErrorType(), CE_Warning);
    4014             : 
    4015           1 :     VSIUnlink("/vsimem/credentials.txt");
    4016             : }
    4017             : 
    4018             : // Test CPLLoadConfigOptionsFromFile() for VSI credentials, warning case
    4019           4 : TEST_F(test_cpl,
    4020             :        CPLLoadConfigOptionsFromFile_VSI_credentials_subsection_warning)
    4021             : {
    4022           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/credentials.txt", "wb");
    4023           1 :     VSIFPrintfL(fp, "[credentials]\n");
    4024           1 :     VSIFPrintfL(fp, "[.subsection]\n");
    4025           1 :     VSIFPrintfL(fp, "FOO=BAR\n");  // first key is not 'path'
    4026           1 :     VSIFCloseL(fp);
    4027             : 
    4028           1 :     CPLErrorReset();
    4029           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    4030           1 :     CPLLoadConfigOptionsFromFile("/vsimem/credentials.txt", false);
    4031           1 :     CPLPopErrorHandler();
    4032           1 :     ASSERT_EQ(CPLGetLastErrorType(), CE_Warning);
    4033             : 
    4034           1 :     VSIUnlink("/vsimem/credentials.txt");
    4035             : }
    4036             : 
    4037             : // Test CPLLoadConfigOptionsFromFile() for VSI credentials, warning case
    4038           4 : TEST_F(test_cpl,
    4039             :        CPLLoadConfigOptionsFromFile_VSI_credentials_warning_path_specific)
    4040             : {
    4041           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/credentials.txt", "wb");
    4042           1 :     VSIFPrintfL(fp, "[credentials]\n");
    4043           1 :     VSIFPrintfL(fp, "[.subsection]\n");
    4044           1 :     VSIFPrintfL(fp, "path=/vsi_test/foo\n");
    4045           1 :     VSIFPrintfL(fp, "path=/vsi_test/bar\n");  // duplicated path
    4046           1 :     VSIFPrintfL(fp, "FOO=BAR\n");             // first key is not 'path'
    4047           1 :     VSIFPrintfL(fp, "[unrelated_section]");
    4048           1 :     VSIFPrintfL(fp, "BAR=BAZ\n");  // first key is not 'path'
    4049           1 :     VSIFCloseL(fp);
    4050             : 
    4051           1 :     CPLErrorReset();
    4052           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    4053           1 :     CPLLoadConfigOptionsFromFile("/vsimem/credentials.txt", false);
    4054           1 :     CPLPopErrorHandler();
    4055           1 :     ASSERT_EQ(CPLGetLastErrorType(), CE_Warning);
    4056             : 
    4057             :     {
    4058             :         const char *pszVal =
    4059           1 :             VSIGetPathSpecificOption("/vsi_test/foo", "FOO", nullptr);
    4060           1 :         ASSERT_TRUE(pszVal != nullptr);
    4061             :     }
    4062             : 
    4063             :     {
    4064             :         const char *pszVal =
    4065           1 :             VSIGetPathSpecificOption("/vsi_test/foo", "BAR", nullptr);
    4066           1 :         ASSERT_TRUE(pszVal == nullptr);
    4067             :     }
    4068             : 
    4069           1 :     VSIUnlink("/vsimem/credentials.txt");
    4070             : }
    4071             : 
    4072             : // Test CPLRecodeFromWCharIconv() with 2 bytes/char source encoding
    4073           4 : TEST_F(test_cpl, CPLRecodeFromWCharIconv_2byte_source_encoding)
    4074             : {
    4075             : #ifdef CPL_RECODE_ICONV
    4076           1 :     int N = 2048;
    4077             :     wchar_t *pszIn =
    4078           1 :         static_cast<wchar_t *>(CPLMalloc((N + 1) * sizeof(wchar_t)));
    4079        2049 :     for (int i = 0; i < N; i++)
    4080        2048 :         pszIn[i] = L'A';
    4081           1 :     pszIn[N] = L'\0';
    4082           1 :     char *pszExpected = static_cast<char *>(CPLMalloc(N + 1));
    4083        2049 :     for (int i = 0; i < N; i++)
    4084        2048 :         pszExpected[i] = 'A';
    4085           1 :     pszExpected[N] = '\0';
    4086           1 :     char *pszRet = CPLRecodeFromWChar(pszIn, CPL_ENC_UTF16, CPL_ENC_UTF8);
    4087           1 :     const bool bOK = memcmp(pszExpected, pszRet, N + 1) == 0;
    4088             :     // FIXME Some tests fail on Mac. Not sure why, but do not error out just for
    4089             :     // that
    4090           1 :     if (!bOK &&
    4091           0 :         (strstr(CPLGetConfigOption("TRAVIS_OS_NAME", ""), "osx") != nullptr ||
    4092           0 :          strstr(CPLGetConfigOption("BUILD_NAME", ""), "osx") != nullptr ||
    4093           0 :          getenv("DO_NOT_FAIL_ON_RECODE_ERRORS") != nullptr))
    4094             :     {
    4095           0 :         fprintf(stderr, "Recode from CPL_ENC_UTF16 to CPL_ENC_UTF8 failed\n");
    4096             :     }
    4097             :     else
    4098             :     {
    4099           1 :         EXPECT_TRUE(bOK);
    4100             :     }
    4101           1 :     CPLFree(pszIn);
    4102           1 :     CPLFree(pszRet);
    4103           1 :     CPLFree(pszExpected);
    4104             : #else
    4105             :     GTEST_SKIP() << "iconv support missing";
    4106             : #endif
    4107           1 : }
    4108             : 
    4109             : // VERY MINIMAL testing of VSI plugin functionality
    4110           4 : TEST_F(test_cpl, VSI_plugin_minimal_testing)
    4111             : {
    4112           1 :     auto psCallbacks = VSIAllocFilesystemPluginCallbacksStruct();
    4113           3 :     psCallbacks->open = [](void *pUserData, const char *pszFilename,
    4114             :                            const char *pszAccess) -> void *
    4115             :     {
    4116             :         (void)pUserData;
    4117           2 :         if (strcmp(pszFilename, "test") == 0 && strcmp(pszAccess, "rb") == 0)
    4118           1 :             return const_cast<char *>("ok");
    4119           1 :         return nullptr;
    4120           1 :     };
    4121           1 :     EXPECT_EQ(VSIInstallPluginHandler("/vsimyplugin/", psCallbacks), 0);
    4122           1 :     VSIFreeFilesystemPluginCallbacksStruct(psCallbacks);
    4123           1 :     VSILFILE *fp = VSIFOpenL("/vsimyplugin/test", "rb");
    4124           1 :     EXPECT_TRUE(fp != nullptr);
    4125             : 
    4126             :     // Check it doesn't crash
    4127           1 :     vsi_l_offset nOffset = 5;
    4128           1 :     size_t nSize = 10;
    4129           1 :     reinterpret_cast<VSIVirtualHandle *>(fp)->AdviseRead(1, &nOffset, &nSize);
    4130             : 
    4131           1 :     VSIFCloseL(fp);
    4132           1 :     EXPECT_TRUE(VSIVirtualHandleUniquePtr(
    4133             :                     VSIFOpenL("/vsimyplugin/i_dont_exist", "rb")) == nullptr);
    4134             : 
    4135             :     // Check that we can remove the handler
    4136           1 :     VSIRemovePluginHandler("/vsimyplugin/");
    4137             : 
    4138           1 :     EXPECT_TRUE(VSIVirtualHandleUniquePtr(
    4139             :                     VSIFOpenL("/vsimyplugin/test", "rb")) == nullptr);
    4140           1 :     EXPECT_TRUE(VSIVirtualHandleUniquePtr(
    4141             :                     VSIFOpenL("/vsimyplugin/i_dont_exist", "rb")) == nullptr);
    4142             : 
    4143             :     // Removing a non-existing handler is a no-op
    4144           1 :     VSIRemovePluginHandler("/vsimyplugin/");
    4145           1 :     VSIRemovePluginHandler("/vsifoobar/");
    4146           1 : }
    4147             : 
    4148           4 : TEST_F(test_cpl, VSI_plugin_advise_read)
    4149             : {
    4150           1 :     auto psCallbacks = VSIAllocFilesystemPluginCallbacksStruct();
    4151             : 
    4152             :     struct UserData
    4153             :     {
    4154             :         int nRanges = 0;
    4155             :         const vsi_l_offset *panOffsets = nullptr;
    4156             :         const size_t *panSizes = nullptr;
    4157             :     };
    4158             : 
    4159           1 :     UserData userData;
    4160             : 
    4161           1 :     psCallbacks->pUserData = &userData;
    4162           2 :     psCallbacks->open = [](void *pUserData, const char * /*pszFilename*/,
    4163             :                            const char * /*pszAccess*/) -> void *
    4164           2 :     { return pUserData; };
    4165             : 
    4166           2 :     psCallbacks->advise_read = [](void *pFile, int nRanges,
    4167             :                                   const vsi_l_offset *panOffsets,
    4168             :                                   const size_t *panSizes)
    4169             :     {
    4170           1 :         static_cast<UserData *>(pFile)->nRanges = nRanges;
    4171           1 :         static_cast<UserData *>(pFile)->panOffsets = panOffsets;
    4172           1 :         static_cast<UserData *>(pFile)->panSizes = panSizes;
    4173           2 :     };
    4174           1 :     EXPECT_EQ(VSIInstallPluginHandler("/VSI_plugin_advise_read/", psCallbacks),
    4175             :               0);
    4176           1 :     VSIFreeFilesystemPluginCallbacksStruct(psCallbacks);
    4177           1 :     VSILFILE *fp = VSIFOpenL("/VSI_plugin_advise_read/test", "rb");
    4178           1 :     EXPECT_TRUE(fp != nullptr);
    4179             : 
    4180           1 :     vsi_l_offset nOffset = 5;
    4181           1 :     size_t nSize = 10;
    4182           1 :     reinterpret_cast<VSIVirtualHandle *>(fp)->AdviseRead(1, &nOffset, &nSize);
    4183           1 :     EXPECT_EQ(userData.nRanges, 1);
    4184           1 :     EXPECT_EQ(userData.panOffsets, &nOffset);
    4185           1 :     EXPECT_EQ(userData.panSizes, &nSize);
    4186             : 
    4187           1 :     VSIFCloseL(fp);
    4188           1 : }
    4189             : 
    4190             : // Test CPLIsASCII()
    4191           4 : TEST_F(test_cpl, CPLIsASCII)
    4192             : {
    4193           1 :     ASSERT_TRUE(CPLIsASCII("foo", 3));
    4194           1 :     ASSERT_TRUE(CPLIsASCII("foo", static_cast<size_t>(-1)));
    4195           1 :     ASSERT_TRUE(!CPLIsASCII("\xFF", 1));
    4196             : }
    4197             : 
    4198             : // Test VSIIsLocal()
    4199           4 : TEST_F(test_cpl, VSIIsLocal)
    4200             : {
    4201           1 :     ASSERT_TRUE(VSIIsLocal("/vsimem/"));
    4202           1 :     ASSERT_TRUE(VSIIsLocal("/vsigzip//vsimem/tmp.gz"));
    4203             : #ifdef HAVE_CURL
    4204           1 :     ASSERT_TRUE(!VSIIsLocal("/vsicurl/http://example.com"));
    4205             : #endif
    4206             :     VSIStatBufL sStat;
    4207             : #ifdef _WIN32
    4208             :     if (VSIStatL("c:\\", &sStat) == 0)
    4209             :     {
    4210             :         ASSERT_TRUE(VSIIsLocal("c:\\i_do_not_exist"));
    4211             :     }
    4212             : #else
    4213           1 :     if (VSIStatL("/tmp", &sStat) == 0)
    4214             :     {
    4215           1 :         ASSERT_TRUE(VSIIsLocal("/tmp/i_do_not_exist"));
    4216             :     }
    4217             : #endif
    4218             : }
    4219             : 
    4220             : // Test VSISupportsSequentialWrite()
    4221           4 : TEST_F(test_cpl, VSISupportsSequentialWrite)
    4222             : {
    4223           1 :     ASSERT_TRUE(VSISupportsSequentialWrite("/vsimem/", false));
    4224             : #ifdef HAVE_CURL
    4225           1 :     ASSERT_TRUE(
    4226             :         !VSISupportsSequentialWrite("/vsicurl/http://example.com", false));
    4227           1 :     ASSERT_TRUE(VSISupportsSequentialWrite("/vsis3/test_bucket/", false));
    4228             : #endif
    4229           1 :     ASSERT_TRUE(VSISupportsSequentialWrite("/vsigzip//vsimem/tmp.gz", false));
    4230             : #ifdef HAVE_CURL
    4231           1 :     ASSERT_TRUE(!VSISupportsSequentialWrite(
    4232             :         "/vsigzip//vsicurl/http://example.com/tmp.gz", false));
    4233             : #endif
    4234             :     VSIStatBufL sStat;
    4235             : #ifdef _WIN32
    4236             :     if (VSIStatL("c:\\", &sStat) == 0)
    4237             :     {
    4238             :         ASSERT_TRUE(VSISupportsSequentialWrite("c:\\", false));
    4239             :     }
    4240             : #else
    4241           1 :     if (VSIStatL("/tmp", &sStat) == 0)
    4242             :     {
    4243           1 :         ASSERT_TRUE(VSISupportsSequentialWrite("/tmp/i_do_not_exist", false));
    4244             :     }
    4245             : #endif
    4246             : }
    4247             : 
    4248             : // Test VSISupportsRandomWrite()
    4249           4 : TEST_F(test_cpl, VSISupportsRandomWrite)
    4250             : {
    4251           1 :     ASSERT_TRUE(VSISupportsRandomWrite("/vsimem/", false));
    4252             : #ifdef HAVE_CURL
    4253           1 :     ASSERT_TRUE(!VSISupportsRandomWrite("/vsicurl/http://example.com", false));
    4254           1 :     ASSERT_TRUE(!VSISupportsRandomWrite("/vsis3/test_bucket/", false));
    4255           1 :     ASSERT_TRUE(!VSISupportsRandomWrite("/vsis3/test_bucket/", true));
    4256           1 :     CPLSetConfigOption("CPL_VSIL_USE_TEMP_FILE_FOR_RANDOM_WRITE", "YES");
    4257           1 :     ASSERT_TRUE(VSISupportsRandomWrite("/vsis3/test_bucket/", true));
    4258           1 :     CPLSetConfigOption("CPL_VSIL_USE_TEMP_FILE_FOR_RANDOM_WRITE", nullptr);
    4259             : #endif
    4260           1 :     ASSERT_TRUE(!VSISupportsRandomWrite("/vsigzip//vsimem/tmp.gz", false));
    4261             : #ifdef HAVE_CURL
    4262           1 :     ASSERT_TRUE(!VSISupportsRandomWrite(
    4263             :         "/vsigzip//vsicurl/http://example.com/tmp.gz", false));
    4264             : #endif
    4265             :     VSIStatBufL sStat;
    4266             : #ifdef _WIN32
    4267             :     if (VSIStatL("c:\\", &sStat) == 0)
    4268             :     {
    4269             :         ASSERT_TRUE(VSISupportsRandomWrite("c:\\", false));
    4270             :     }
    4271             : #else
    4272           1 :     if (VSIStatL("/tmp", &sStat) == 0)
    4273             :     {
    4274           1 :         ASSERT_TRUE(VSISupportsRandomWrite("/tmp", false));
    4275             :     }
    4276             : #endif
    4277             : }
    4278             : 
    4279             : // Test ignore-env-vars = yes of configuration file
    4280           4 : TEST_F(test_cpl, config_file_ignore_env_vars)
    4281             : {
    4282           1 :     char szEnvVar[] = "SOME_ENV_VAR_FOR_TEST_CPL_61=FOO";
    4283           1 :     putenv(szEnvVar);
    4284           1 :     ASSERT_STREQ(CPLGetConfigOption("SOME_ENV_VAR_FOR_TEST_CPL_61", nullptr),
    4285             :                  "FOO");
    4286             : 
    4287           1 :     VSILFILE *fp = VSIFOpenL("/vsimem/.gdal/gdalrc", "wb");
    4288           1 :     VSIFPrintfL(fp, "[directives]\n");
    4289           1 :     VSIFPrintfL(fp, "ignore-env-vars=yes\n");
    4290           1 :     VSIFPrintfL(fp, "[configoptions]\n");
    4291           1 :     VSIFPrintfL(fp, "CONFIG_OPTION_FOR_TEST_CPL_61=BAR\n");
    4292           1 :     VSIFCloseL(fp);
    4293             : 
    4294             :     // Load configuration file
    4295           1 :     constexpr bool bOverrideEnvVars = false;
    4296           1 :     CPLLoadConfigOptionsFromFile("/vsimem/.gdal/gdalrc", bOverrideEnvVars);
    4297             : 
    4298             :     // Check that reading configuration option works
    4299           1 :     ASSERT_STREQ(CPLGetConfigOption("CONFIG_OPTION_FOR_TEST_CPL_61", ""),
    4300             :                  "BAR");
    4301             : 
    4302             :     // Check that environment variables are not read as configuration options
    4303           1 :     ASSERT_TRUE(CPLGetConfigOption("SOME_ENV_VAR_FOR_TEST_CPL_61", nullptr) ==
    4304             :                 nullptr);
    4305             : 
    4306             :     // Reset ignore-env-vars=no
    4307           1 :     fp = VSIFOpenL("/vsimem/.gdal/gdalrc", "wb");
    4308           1 :     VSIFPrintfL(fp, "[directives]\n");
    4309           1 :     VSIFPrintfL(fp, "ignore-env-vars=no\n");
    4310           1 :     VSIFPrintfL(fp, "[configoptions]\n");
    4311           1 :     VSIFPrintfL(fp, "SOME_ENV_VAR_FOR_TEST_CPL_61=BAR\n");
    4312           1 :     VSIFCloseL(fp);
    4313             : 
    4314             :     // Reload configuration file
    4315           1 :     CPLLoadConfigOptionsFromFile("/vsimem/.gdal/gdalrc", false);
    4316             : 
    4317             :     // Check that environment variables override configuration options defined
    4318             :     // in the file (config file was loaded with bOverrideEnvVars = false)
    4319           1 :     ASSERT_TRUE(CPLGetConfigOption("SOME_ENV_VAR_FOR_TEST_CPL_61", nullptr) !=
    4320             :                 nullptr);
    4321           1 :     ASSERT_STREQ(CPLGetConfigOption("SOME_ENV_VAR_FOR_TEST_CPL_61", ""), "FOO");
    4322             : 
    4323           1 :     VSIUnlink("/vsimem/.gdal/gdalrc");
    4324             : }
    4325             : 
    4326             : // Test that explicitly defined configuration options override environment variables
    4327             : // with the same name
    4328           4 : TEST_F(test_cpl, test_config_overrides_environment)
    4329             : {
    4330           1 :     char szEnvVar[] = "TEST_CONFIG_OVERRIDES_ENVIRONMENT=123";
    4331           1 :     putenv(szEnvVar);
    4332             : 
    4333           1 :     ASSERT_STREQ(
    4334             :         CPLGetConfigOption("TEST_CONFIG_OVERRIDES_ENVIRONMENT", nullptr),
    4335             :         "123");
    4336             : 
    4337           1 :     CPLSetConfigOption("TEST_CONFIG_OVERRIDES_ENVIRONMENT", "456");
    4338             : 
    4339           1 :     ASSERT_STREQ(
    4340             :         CPLGetConfigOption("TEST_CONFIG_OVERRIDES_ENVIRONMENT", nullptr),
    4341             :         "456");
    4342             : 
    4343           1 :     CPLSetConfigOption("TEST_CONFIG_OVERRIDES_ENVIRONMENT", nullptr);
    4344             : 
    4345           1 :     ASSERT_STREQ(
    4346             :         CPLGetConfigOption("TEST_CONFIG_OVERRIDES_ENVIRONMENT", nullptr),
    4347             :         "123");
    4348             : }
    4349             : 
    4350             : // Test CPLWorkerThreadPool recursion
    4351           4 : TEST_F(test_cpl, CPLWorkerThreadPool_recursion)
    4352             : {
    4353             :     struct Context
    4354             :     {
    4355             :         CPLWorkerThreadPool oThreadPool{};
    4356             :         std::atomic<int> nCounter{0};
    4357             :         std::mutex mutex{};
    4358             :         std::condition_variable cv{};
    4359             :         bool you_can_leave = false;
    4360             :         int threadStarted = 0;
    4361             : 
    4362           1 :         void notifyYouCanLeave()
    4363             :         {
    4364           2 :             std::lock_guard<std::mutex> guard(mutex);
    4365           1 :             you_can_leave = true;
    4366           1 :             cv.notify_one();
    4367           1 :         }
    4368             : 
    4369           1 :         void waitYouCanLeave()
    4370             :         {
    4371           2 :             std::unique_lock<std::mutex> guard(mutex);
    4372           1 :             while (!you_can_leave)
    4373             :             {
    4374           0 :                 cv.wait(guard);
    4375             :             }
    4376           1 :         }
    4377             :     };
    4378             : 
    4379           1 :     Context ctxt;
    4380           1 :     ctxt.oThreadPool.Setup(2, nullptr, nullptr, /* waitAllStarted = */ true);
    4381             : 
    4382             :     struct Data
    4383             :     {
    4384             :         Context *psCtxt;
    4385             :         int iJob;
    4386             :         GIntBig nThreadLambda = 0;
    4387             : 
    4388           3 :         Data(Context *psCtxtIn, int iJobIn) : psCtxt(psCtxtIn), iJob(iJobIn)
    4389             :         {
    4390           3 :         }
    4391             : 
    4392             :         Data(const Data &) = default;
    4393             :     };
    4394             : 
    4395           3 :     const auto lambda = [](void *pData)
    4396             :     {
    4397           3 :         auto psData = static_cast<Data *>(pData);
    4398           3 :         if (psData->iJob > 0)
    4399             :         {
    4400             :             // wait for both threads to be started
    4401           4 :             std::unique_lock<std::mutex> guard(psData->psCtxt->mutex);
    4402           2 :             psData->psCtxt->threadStarted++;
    4403           2 :             psData->psCtxt->cv.notify_one();
    4404           3 :             while (psData->psCtxt->threadStarted < 2)
    4405             :             {
    4406           1 :                 psData->psCtxt->cv.wait(guard);
    4407             :             }
    4408             :         }
    4409             : 
    4410           3 :         psData->nThreadLambda = CPLGetPID();
    4411             :         // fprintf(stderr, "lambda %d: " CPL_FRMT_GIB "\n",
    4412             :         //         psData->iJob, psData->nThreadLambda);
    4413           9 :         const auto lambda2 = [](void *pData2)
    4414             :         {
    4415           9 :             const auto psData2 = static_cast<Data *>(pData2);
    4416           9 :             const int iJob = psData2->iJob;
    4417           9 :             const int nCounter = psData2->psCtxt->nCounter++;
    4418           9 :             CPL_IGNORE_RET_VAL(nCounter);
    4419           9 :             const auto nThreadLambda2 = CPLGetPID();
    4420             :             // fprintf(stderr, "lambda2 job=%d, counter(before)=%d, thread="
    4421             :             // CPL_FRMT_GIB "\n", iJob, nCounter, nThreadLambda2);
    4422           9 :             if (iJob == 100 + 0)
    4423             :             {
    4424           1 :                 ASSERT_TRUE(nThreadLambda2 != psData2->nThreadLambda);
    4425             :                 // make sure that job 0 run in the other thread
    4426             :                 // takes sufficiently long that job 2 has been submitted
    4427             :                 // before it completes
    4428           1 :                 psData2->psCtxt->waitYouCanLeave();
    4429             :             }
    4430           8 :             else if (iJob == 100 + 1 || iJob == 100 + 2)
    4431             :             {
    4432           2 :                 ASSERT_TRUE(nThreadLambda2 == psData2->nThreadLambda);
    4433             :             }
    4434             :         };
    4435           6 :         auto poQueue = psData->psCtxt->oThreadPool.CreateJobQueue();
    4436           3 :         Data d0(*psData);
    4437           3 :         d0.iJob = 100 + d0.iJob * 3 + 0;
    4438           3 :         Data d1(*psData);
    4439           3 :         d1.iJob = 100 + d1.iJob * 3 + 1;
    4440           3 :         Data d2(*psData);
    4441           3 :         d2.iJob = 100 + d2.iJob * 3 + 2;
    4442           3 :         poQueue->SubmitJob(lambda2, &d0);
    4443           3 :         poQueue->SubmitJob(lambda2, &d1);
    4444           3 :         poQueue->SubmitJob(lambda2, &d2);
    4445           3 :         if (psData->iJob == 0)
    4446             :         {
    4447           1 :             psData->psCtxt->notifyYouCanLeave();
    4448             :         }
    4449           3 :     };
    4450             :     {
    4451           2 :         auto poQueue = ctxt.oThreadPool.CreateJobQueue();
    4452           1 :         Data data0(&ctxt, 0);
    4453           1 :         poQueue->SubmitJob(lambda, &data0);
    4454             :     }
    4455             :     {
    4456           2 :         auto poQueue = ctxt.oThreadPool.CreateJobQueue();
    4457           1 :         Data data1(&ctxt, 1);
    4458           1 :         Data data2(&ctxt, 2);
    4459           1 :         poQueue->SubmitJob(lambda, &data1);
    4460           1 :         poQueue->SubmitJob(lambda, &data2);
    4461             :     }
    4462           1 :     ASSERT_EQ(ctxt.nCounter, 3 * 3);
    4463             : }
    4464             : 
    4465             : // Test /vsimem/ PRead() implementation
    4466           4 : TEST_F(test_cpl, vsimem_pread)
    4467             : {
    4468           1 :     char szContent[] = "abcd";
    4469           1 :     VSILFILE *fp = VSIFileFromMemBuffer(
    4470             :         "", reinterpret_cast<GByte *>(szContent), 4, FALSE);
    4471           1 :     VSIVirtualHandle *poHandle = reinterpret_cast<VSIVirtualHandle *>(fp);
    4472           1 :     ASSERT_TRUE(poHandle->HasPRead());
    4473             :     {
    4474           1 :         char szBuffer[5] = {0};
    4475           1 :         ASSERT_EQ(poHandle->PRead(szBuffer, 2, 1), 2U);
    4476           2 :         ASSERT_EQ(std::string(szBuffer), std::string("bc"));
    4477             :     }
    4478             :     {
    4479           1 :         char szBuffer[5] = {0};
    4480           1 :         ASSERT_EQ(poHandle->PRead(szBuffer, 4, 1), 3U);
    4481           2 :         ASSERT_EQ(std::string(szBuffer), std::string("bcd"));
    4482             :     }
    4483             :     {
    4484           1 :         char szBuffer[5] = {0};
    4485           1 :         ASSERT_EQ(poHandle->PRead(szBuffer, 1, 4), 0U);
    4486           2 :         ASSERT_EQ(std::string(szBuffer), std::string());
    4487             :     }
    4488           1 :     VSIFCloseL(fp);
    4489             : }
    4490             : 
    4491             : // Test regular file system PRead() implementation
    4492           4 : TEST_F(test_cpl, file_system_pread)
    4493             : {
    4494           1 :     VSILFILE *fp = VSIFOpenL("temp_test_64.bin", "wb+");
    4495           1 :     if (fp == nullptr)
    4496           0 :         return;
    4497           1 :     VSIVirtualHandle *poHandle = reinterpret_cast<VSIVirtualHandle *>(fp);
    4498           1 :     poHandle->Write("abcd", 4, 1);
    4499           1 :     if (poHandle->HasPRead())
    4500             :     {
    4501           1 :         poHandle->Flush();
    4502             :         {
    4503           1 :             char szBuffer[5] = {0};
    4504           1 :             ASSERT_EQ(poHandle->PRead(szBuffer, 2, 1), 2U);
    4505           2 :             ASSERT_EQ(std::string(szBuffer), std::string("bc"));
    4506             :         }
    4507             :         {
    4508           1 :             char szBuffer[5] = {0};
    4509           1 :             ASSERT_EQ(poHandle->PRead(szBuffer, 4, 1), 3U);
    4510           2 :             ASSERT_EQ(std::string(szBuffer), std::string("bcd"));
    4511             :         }
    4512             :         {
    4513           1 :             char szBuffer[5] = {0};
    4514           1 :             ASSERT_EQ(poHandle->PRead(szBuffer, 1, 4), 0U);
    4515           2 :             ASSERT_EQ(std::string(szBuffer), std::string());
    4516             :         }
    4517             :     }
    4518           1 :     VSIFCloseL(fp);
    4519           1 :     VSIUnlink("temp_test_64.bin");
    4520             : }
    4521             : 
    4522             : // Test CPLMask implementation
    4523           4 : TEST_F(test_cpl, CPLMask)
    4524             : {
    4525           1 :     constexpr std::size_t sz = 71;
    4526           1 :     auto m = CPLMaskCreate(sz, true);
    4527             : 
    4528             :     // Mask is set by default
    4529          72 :     for (std::size_t i = 0; i < sz; i++)
    4530             :     {
    4531          71 :         EXPECT_EQ(CPLMaskGet(m, i), true) << "bit " << i;
    4532             :     }
    4533             : 
    4534           1 :     VSIFree(m);
    4535           1 :     m = CPLMaskCreate(sz, false);
    4536           1 :     auto m2 = CPLMaskCreate(sz, false);
    4537             : 
    4538             :     // Mask is unset by default
    4539          72 :     for (std::size_t i = 0; i < sz; i++)
    4540             :     {
    4541          71 :         EXPECT_EQ(CPLMaskGet(m, i), false) << "bit " << i;
    4542             :     }
    4543             : 
    4544             :     // Set a few bits
    4545           1 :     CPLMaskSet(m, 10);
    4546           1 :     CPLMaskSet(m, 33);
    4547           1 :     CPLMaskSet(m, 70);
    4548             : 
    4549             :     // Check all bits
    4550          72 :     for (std::size_t i = 0; i < sz; i++)
    4551             :     {
    4552          71 :         if (i == 10 || i == 33 || i == 70)
    4553             :         {
    4554           3 :             EXPECT_EQ(CPLMaskGet(m, i), true) << "bit " << i;
    4555             :         }
    4556             :         else
    4557             :         {
    4558          68 :             EXPECT_EQ(CPLMaskGet(m, i), false) << "bit " << i;
    4559             :         }
    4560             :     }
    4561             : 
    4562             :     // Unset some bits
    4563           1 :     CPLMaskClear(m, 10);
    4564           1 :     CPLMaskClear(m, 70);
    4565             : 
    4566             :     // Check all bits
    4567          72 :     for (std::size_t i = 0; i < sz; i++)
    4568             :     {
    4569          71 :         if (i == 33)
    4570             :         {
    4571           1 :             EXPECT_EQ(CPLMaskGet(m, i), true) << "bit " << i;
    4572             :         }
    4573             :         else
    4574             :         {
    4575          70 :             EXPECT_EQ(CPLMaskGet(m, i), false) << "bit " << i;
    4576             :         }
    4577             :     }
    4578             : 
    4579           1 :     CPLMaskSet(m2, 36);
    4580           1 :     CPLMaskMerge(m2, m, sz);
    4581             : 
    4582             :     // Check all bits
    4583          72 :     for (std::size_t i = 0; i < sz; i++)
    4584             :     {
    4585          71 :         if (i == 36 || i == 33)
    4586             :         {
    4587           4 :             ASSERT_EQ(CPLMaskGet(m2, i), true) << "bit " << i;
    4588             :         }
    4589             :         else
    4590             :         {
    4591          69 :             ASSERT_EQ(CPLMaskGet(m2, i), false) << "bit " << i;
    4592             :         }
    4593             :     }
    4594             : 
    4595           1 :     CPLMaskClearAll(m, sz);
    4596           1 :     CPLMaskSetAll(m2, sz);
    4597             : 
    4598             :     // Check all bits
    4599          72 :     for (std::size_t i = 0; i < sz; i++)
    4600             :     {
    4601          71 :         EXPECT_EQ(CPLMaskGet(m, i), false) << "bit " << i;
    4602          71 :         EXPECT_EQ(CPLMaskGet(m2, i), true) << "bit " << i;
    4603             :     }
    4604             : 
    4605           1 :     VSIFree(m);
    4606           1 :     VSIFree(m2);
    4607             : }
    4608             : 
    4609             : // Test cpl::ThreadSafeQueue
    4610           4 : TEST_F(test_cpl, ThreadSafeQueue)
    4611             : {
    4612           1 :     cpl::ThreadSafeQueue<int> queue;
    4613           1 :     ASSERT_TRUE(queue.empty());
    4614           1 :     ASSERT_EQ(queue.size(), 0U);
    4615           1 :     queue.push(1);
    4616           1 :     ASSERT_TRUE(!queue.empty());
    4617           1 :     ASSERT_EQ(queue.size(), 1U);
    4618           1 :     queue.clear();
    4619           1 :     ASSERT_TRUE(queue.empty());
    4620           1 :     ASSERT_EQ(queue.size(), 0U);
    4621           1 :     int val = 10;
    4622           1 :     queue.push(std::move(val));
    4623           1 :     ASSERT_TRUE(!queue.empty());
    4624           1 :     ASSERT_EQ(queue.size(), 1U);
    4625           1 :     ASSERT_EQ(queue.get_and_pop_front(), 10);
    4626           1 :     ASSERT_TRUE(queue.empty());
    4627             : }
    4628             : 
    4629           4 : TEST_F(test_cpl, CPLGetExecPath)
    4630             : {
    4631           1 :     std::vector<char> achBuffer(1024, 'x');
    4632           1 :     if (!CPLGetExecPath(achBuffer.data(), static_cast<int>(achBuffer.size())))
    4633             :     {
    4634           0 :         GTEST_SKIP() << "CPLGetExecPath() not implemented for this platform";
    4635             :     }
    4636             :     else
    4637             :     {
    4638           1 :         bool bFoundNulTerminatedChar = false;
    4639          71 :         for (char ch : achBuffer)
    4640             :         {
    4641          71 :             if (ch == '\0')
    4642             :             {
    4643           1 :                 bFoundNulTerminatedChar = true;
    4644           1 :                 break;
    4645             :             }
    4646             :         }
    4647           1 :         ASSERT_TRUE(bFoundNulTerminatedChar);
    4648             : 
    4649             :         // Check that the file exists
    4650             :         VSIStatBufL sStat;
    4651           1 :         EXPECT_EQ(VSIStatL(achBuffer.data(), &sStat), 0);
    4652             : 
    4653           2 :         const std::string osStrBefore(achBuffer.data());
    4654             : 
    4655             :         // Resize the buffer to just the minimum size
    4656           1 :         achBuffer.resize(strlen(achBuffer.data()) + 1);
    4657           1 :         EXPECT_TRUE(CPLGetExecPath(achBuffer.data(),
    4658             :                                    static_cast<int>(achBuffer.size())));
    4659             : 
    4660           1 :         EXPECT_STREQ(osStrBefore.c_str(), achBuffer.data());
    4661             : 
    4662             :         // Too small buffer
    4663           1 :         achBuffer.resize(achBuffer.size() - 1);
    4664           1 :         EXPECT_FALSE(CPLGetExecPath(achBuffer.data(),
    4665             :                                     static_cast<int>(achBuffer.size())));
    4666             :     }
    4667             : }
    4668             : 
    4669           4 : TEST_F(test_cpl, VSIDuplicateFileSystemHandler)
    4670             : {
    4671             :     {
    4672           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4673           1 :         EXPECT_FALSE(VSIDuplicateFileSystemHandler(
    4674             :             "/vsi_i_dont_exist/", "/vsi_i_will_not_be_created/"));
    4675             :     }
    4676             :     {
    4677           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4678           1 :         EXPECT_FALSE(
    4679             :             VSIDuplicateFileSystemHandler("/", "/vsi_i_will_not_be_created/"));
    4680             :     }
    4681           1 :     EXPECT_EQ(VSIFileManager::GetHandler("/vsi_test_clone_vsimem/"),
    4682             :               VSIFileManager::GetHandler("/"));
    4683           1 :     EXPECT_TRUE(
    4684             :         VSIDuplicateFileSystemHandler("/vsimem/", "/vsi_test_clone_vsimem/"));
    4685           1 :     EXPECT_NE(VSIFileManager::GetHandler("/vsi_test_clone_vsimem/"),
    4686             :               VSIFileManager::GetHandler("/"));
    4687             :     {
    4688           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4689           1 :         EXPECT_FALSE(VSIDuplicateFileSystemHandler("/vsimem/",
    4690             :                                                    "/vsi_test_clone_vsimem/"));
    4691             :     }
    4692           1 : }
    4693             : 
    4694           4 : TEST_F(test_cpl, CPLAtoGIntBigEx)
    4695             : {
    4696             :     {
    4697           1 :         int bOverflow = 0;
    4698           1 :         EXPECT_EQ(CPLAtoGIntBigEx("9223372036854775807", false, &bOverflow),
    4699             :                   std::numeric_limits<int64_t>::max());
    4700           1 :         EXPECT_EQ(bOverflow, FALSE);
    4701             :     }
    4702             :     {
    4703           1 :         int bOverflow = 0;
    4704           1 :         EXPECT_EQ(CPLAtoGIntBigEx("9223372036854775808", false, &bOverflow),
    4705             :                   std::numeric_limits<int64_t>::max());
    4706           1 :         EXPECT_EQ(bOverflow, TRUE);
    4707             :     }
    4708             :     {
    4709           1 :         int bOverflow = 0;
    4710           1 :         EXPECT_EQ(CPLAtoGIntBigEx("-9223372036854775808", false, &bOverflow),
    4711             :                   std::numeric_limits<int64_t>::min());
    4712           1 :         EXPECT_EQ(bOverflow, FALSE);
    4713             :     }
    4714             :     {
    4715           1 :         int bOverflow = 0;
    4716           1 :         EXPECT_EQ(CPLAtoGIntBigEx("-9223372036854775809", false, &bOverflow),
    4717             :                   std::numeric_limits<int64_t>::min());
    4718           1 :         EXPECT_EQ(bOverflow, TRUE);
    4719             :     }
    4720           1 : }
    4721             : 
    4722           4 : TEST_F(test_cpl, CPLSubscribeToSetConfigOption)
    4723             : {
    4724             :     struct Event
    4725             :     {
    4726             :         std::string osKey;
    4727             :         std::string osValue;
    4728             :         bool bThreadLocal;
    4729             :     };
    4730             : 
    4731           2 :     std::vector<Event> events;
    4732           4 :     const auto cbk = +[](const char *pszKey, const char *pszValue,
    4733             :                          bool bThreadLocal, void *pUserData)
    4734             :     {
    4735           3 :         std::vector<Event> *pEvents =
    4736             :             static_cast<std::vector<Event> *>(pUserData);
    4737           6 :         Event ev;
    4738           3 :         ev.osKey = pszKey;
    4739           3 :         ev.osValue = pszValue ? pszValue : "";
    4740           3 :         ev.bThreadLocal = bThreadLocal;
    4741           3 :         pEvents->emplace_back(ev);
    4742           3 :     };
    4743             : 
    4744             :     // Subscribe and unsubscribe immediately
    4745             :     {
    4746           1 :         int nId = CPLSubscribeToSetConfigOption(cbk, &events);
    4747           1 :         CPLSetConfigOption("CPLSubscribeToSetConfigOption", "bar");
    4748           1 :         EXPECT_EQ(events.size(), 1U);
    4749           1 :         if (!events.empty())
    4750             :         {
    4751           1 :             EXPECT_STREQ(events[0].osKey.c_str(),
    4752             :                          "CPLSubscribeToSetConfigOption");
    4753           1 :             EXPECT_STREQ(events[0].osValue.c_str(), "bar");
    4754           1 :             EXPECT_FALSE(events[0].bThreadLocal);
    4755             :         }
    4756           1 :         CPLUnsubscribeToSetConfigOption(nId);
    4757             :     }
    4758           1 :     events.clear();
    4759             : 
    4760             :     // Subscribe and unsubscribe in non-nested order
    4761             :     {
    4762           1 :         int nId1 = CPLSubscribeToSetConfigOption(cbk, &events);
    4763           1 :         int nId2 = CPLSubscribeToSetConfigOption(cbk, &events);
    4764           1 :         CPLUnsubscribeToSetConfigOption(nId1);
    4765           1 :         int nId3 = CPLSubscribeToSetConfigOption(cbk, &events);
    4766             : 
    4767           1 :         CPLSetConfigOption("CPLSubscribeToSetConfigOption", nullptr);
    4768           1 :         EXPECT_EQ(events.size(), 2U);
    4769             : 
    4770           1 :         CPLUnsubscribeToSetConfigOption(nId2);
    4771           1 :         CPLUnsubscribeToSetConfigOption(nId3);
    4772             : 
    4773           1 :         CPLSetConfigOption("CPLSubscribeToSetConfigOption", nullptr);
    4774           1 :         EXPECT_EQ(events.size(), 2U);
    4775             :     }
    4776           1 : }
    4777             : 
    4778           4 : TEST_F(test_cpl, VSIGetCanonicalFilename)
    4779             : {
    4780           2 :     std::string osTmp = CPLGenerateTempFilename(nullptr);
    4781           1 :     if (!CPLIsFilenameRelative(osTmp.c_str()))
    4782             :     {
    4783             :         // Get the canonical filename of the base temporary file
    4784             :         // to be able to test afterwards just the differences on the case
    4785             :         // of the extension
    4786           0 :         VSILFILE *fp = VSIFOpenL(osTmp.c_str(), "wb");
    4787           0 :         EXPECT_TRUE(fp != nullptr);
    4788           0 :         if (fp)
    4789             :         {
    4790           0 :             VSIFCloseL(fp);
    4791           0 :             char *pszRes = VSIGetCanonicalFilename(osTmp.c_str());
    4792           0 :             osTmp = pszRes;
    4793           0 :             CPLFree(pszRes);
    4794           0 :             VSIUnlink(osTmp.c_str());
    4795             :         }
    4796             :     }
    4797             : 
    4798           2 :     std::string osLC = osTmp + ".tmp";
    4799           2 :     std::string osUC = osTmp + ".TMP";
    4800             :     // Create a file in lower case
    4801           1 :     VSILFILE *fp = VSIFOpenL(osLC.c_str(), "wb");
    4802           1 :     EXPECT_TRUE(fp != nullptr);
    4803           1 :     if (fp)
    4804             :     {
    4805           1 :         VSIFCloseL(fp);
    4806             :         VSIStatBufL sStat;
    4807             :         // And try to stat it in upper case
    4808           1 :         if (VSIStatL(osUC.c_str(), &sStat) == 0)
    4809             :         {
    4810           0 :             char *pszRes = VSIGetCanonicalFilename(osUC.c_str());
    4811           0 :             EXPECT_TRUE(pszRes);
    4812           0 :             if (pszRes)
    4813             :             {
    4814             : #if defined(_WIN32) || (defined(__MACH__) && defined(__APPLE__))
    4815             :                 // On Windows or Mac, we should get the real canonical name,
    4816             :                 // i.e. in lower case
    4817             :                 EXPECT_STREQ(pszRes, osLC.c_str());
    4818             : #else
    4819             :                 // On other operating systems, VSIGetCanonicalFilename()
    4820             :                 // could not be implemented, so be laxer in the check
    4821           0 :                 EXPECT_STREQ(CPLString(pszRes).tolower().c_str(),
    4822             :                              CPLString(osLC).tolower().c_str());
    4823             : #endif
    4824             :             }
    4825           0 :             CPLFree(pszRes);
    4826             :         }
    4827             : 
    4828             :         {
    4829           1 :             char *pszRes = VSIGetCanonicalFilename(osLC.c_str());
    4830           1 :             EXPECT_TRUE(pszRes);
    4831           1 :             if (pszRes)
    4832             :             {
    4833           1 :                 EXPECT_STREQ(pszRes, osLC.c_str());
    4834             :             }
    4835           1 :             CPLFree(pszRes);
    4836             :         }
    4837             :     }
    4838           1 :     VSIUnlink(osLC.c_str());
    4839           1 : }
    4840             : 
    4841           4 : TEST_F(test_cpl, CPLStrtod)
    4842             : {
    4843             :     {
    4844           1 :         const char *pszVal = "5";
    4845           1 :         char *pszEnd = nullptr;
    4846           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd), 5.0);
    4847           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4848             :     }
    4849             : 
    4850             :     {
    4851           1 :         const char *pszVal = "5 foo";
    4852           1 :         char *pszEnd = nullptr;
    4853           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd), 5.0);
    4854           1 :         EXPECT_EQ(pszEnd, pszVal + 1);
    4855             :     }
    4856             : 
    4857             :     {
    4858           1 :         const char *pszVal = "foo";
    4859           1 :         char *pszEnd = nullptr;
    4860           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd), 0.0);
    4861           1 :         EXPECT_EQ(pszEnd, pszVal);
    4862             :     }
    4863             : 
    4864             :     {
    4865           1 :         const char *pszVal = "-inf";
    4866           1 :         char *pszEnd = nullptr;
    4867           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4868             :                   -std::numeric_limits<double>::infinity());
    4869           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4870             :     }
    4871             :     {
    4872           1 :         const char *pszVal = "-Inf";
    4873           1 :         char *pszEnd = nullptr;
    4874           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4875             :                   -std::numeric_limits<double>::infinity());
    4876           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4877             :     }
    4878             :     {
    4879           1 :         const char *pszVal = "-INF";
    4880           1 :         char *pszEnd = nullptr;
    4881           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4882             :                   -std::numeric_limits<double>::infinity());
    4883           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4884             :     }
    4885             :     {
    4886           1 :         const char *pszVal = "-Infinity";
    4887           1 :         char *pszEnd = nullptr;
    4888           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4889             :                   -std::numeric_limits<double>::infinity());
    4890           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4891             :     }
    4892             :     {
    4893           1 :         const char *pszVal = "-1.#INF";
    4894           1 :         char *pszEnd = nullptr;
    4895           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4896             :                   -std::numeric_limits<double>::infinity());
    4897           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4898             :     }
    4899             : 
    4900             :     {
    4901           1 :         const char *pszVal = "inf";
    4902           1 :         char *pszEnd = nullptr;
    4903           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4904             :                   std::numeric_limits<double>::infinity());
    4905           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4906             :     }
    4907             :     {
    4908           1 :         const char *pszVal = "Inf";
    4909           1 :         char *pszEnd = nullptr;
    4910           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4911             :                   std::numeric_limits<double>::infinity());
    4912           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4913             :     }
    4914             :     {
    4915           1 :         const char *pszVal = "INF";
    4916           1 :         char *pszEnd = nullptr;
    4917           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4918             :                   std::numeric_limits<double>::infinity());
    4919           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4920             :     }
    4921             :     {
    4922           1 :         const char *pszVal = "Infinity";
    4923           1 :         char *pszEnd = nullptr;
    4924           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4925             :                   std::numeric_limits<double>::infinity());
    4926           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4927             :     }
    4928             :     {
    4929           1 :         const char *pszVal = "1.#INF";
    4930           1 :         char *pszEnd = nullptr;
    4931           1 :         EXPECT_EQ(CPLStrtod(pszVal, &pszEnd),
    4932             :                   std::numeric_limits<double>::infinity());
    4933           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4934             :     }
    4935             : 
    4936             :     {
    4937           1 :         const char *pszVal = "-1.#QNAN";
    4938           1 :         char *pszEnd = nullptr;
    4939           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4940           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4941             :     }
    4942             :     {
    4943           1 :         const char *pszVal = "-1.#IND";
    4944           1 :         char *pszEnd = nullptr;
    4945           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4946           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4947             :     }
    4948             :     {
    4949           1 :         const char *pszVal = "1.#QNAN";
    4950           1 :         char *pszEnd = nullptr;
    4951           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4952           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4953             :     }
    4954             :     {
    4955           1 :         const char *pszVal = "1.#SNAN";
    4956           1 :         char *pszEnd = nullptr;
    4957           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4958           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4959             :     }
    4960             :     {
    4961           1 :         const char *pszVal = "NaN";
    4962           1 :         char *pszEnd = nullptr;
    4963           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4964           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4965             :     }
    4966             :     {
    4967           1 :         const char *pszVal = "nan";
    4968           1 :         char *pszEnd = nullptr;
    4969           1 :         EXPECT_TRUE(std::isnan(CPLStrtod(pszVal, &pszEnd)));
    4970           1 :         EXPECT_EQ(pszEnd, pszVal + strlen(pszVal));
    4971             :     }
    4972           1 : }
    4973             : 
    4974           4 : TEST_F(test_cpl, CPLStringToComplex)
    4975             : {
    4976           5 :     const auto EXPECT_PARSED = [](const char *str, double real, double imag)
    4977             :     {
    4978           5 :         double r = -999;
    4979           5 :         double i = -999;
    4980           5 :         EXPECT_EQ(CPLStringToComplex(str, &r, &i), CE_None)
    4981           0 :             << "Unexpected error parsing " << str;
    4982           5 :         EXPECT_EQ(r, real);
    4983           5 :         EXPECT_EQ(i, imag);
    4984           5 :     };
    4985          10 :     const auto EXPECT_ERROR = [](const char *str)
    4986             :     {
    4987          20 :         CPLErrorStateBackuper state(CPLQuietErrorHandler);
    4988             :         double r, i;
    4989          10 :         EXPECT_EQ(CPLStringToComplex(str, &r, &i), CE_Failure)
    4990           0 :             << "Did not receive expected error parsing " << str;
    4991          10 :     };
    4992             : 
    4993           1 :     EXPECT_PARSED("05401", 5401, 0);
    4994           1 :     EXPECT_PARSED("-5401", -5401, 0);
    4995           1 :     EXPECT_PARSED(" 611.2-38.4i", 611.2, -38.4);
    4996           1 :     EXPECT_PARSED("611.2+38.4i ", 611.2, 38.4);
    4997           1 :     EXPECT_PARSED("-611.2+38.4i", -611.2, 38.4);
    4998             : 
    4999           1 :     EXPECT_ERROR("-611.2+38.4ii");
    5000           1 :     EXPECT_ERROR("-611.2+38.4ji");
    5001           1 :     EXPECT_ERROR("-611.2+38.4ij");
    5002           1 :     EXPECT_ERROR("f-611.2+38.4i");
    5003           1 :     EXPECT_ERROR("-611.2+f38.4i");
    5004           1 :     EXPECT_ERROR("-611.2+-38.4i");
    5005           1 :     EXPECT_ERROR("611.2+38.4");
    5006           1 :     EXPECT_ERROR("38.4i");
    5007           1 :     EXPECT_ERROR("38.4x");
    5008           1 :     EXPECT_ERROR("invalid");
    5009           1 : }
    5010             : 
    5011           4 : TEST_F(test_cpl, CPLForceToASCII)
    5012             : {
    5013             :     {
    5014           1 :         char *pszOut = CPLForceToASCII("foo", -1, '_');
    5015           1 :         EXPECT_STREQ(pszOut, "foo");
    5016           1 :         CPLFree(pszOut);
    5017             :     }
    5018             :     {
    5019           1 :         char *pszOut = CPLForceToASCII("foo", 1, '_');
    5020           1 :         EXPECT_STREQ(pszOut, "f");
    5021           1 :         CPLFree(pszOut);
    5022             :     }
    5023             :     {
    5024           1 :         char *pszOut = CPLForceToASCII("foo\xFF", -1, '_');
    5025           1 :         EXPECT_STREQ(pszOut, "foo_");
    5026           1 :         CPLFree(pszOut);
    5027             :     }
    5028           1 : }
    5029             : 
    5030           4 : TEST_F(test_cpl, CPLUTF8ForceToASCII)
    5031             : {
    5032             :     {
    5033           1 :         char *pszOut = CPLUTF8ForceToASCII("foo", '_');
    5034           1 :         EXPECT_STREQ(pszOut, "foo");
    5035           1 :         CPLFree(pszOut);
    5036             :     }
    5037             :     {
    5038             :         // Truncated UTF-8 character
    5039           1 :         char *pszOut = CPLUTF8ForceToASCII("foo\xC0", '_');
    5040           1 :         EXPECT_STREQ(pszOut, "foo");
    5041           1 :         CPLFree(pszOut);
    5042             :     }
    5043             :     {
    5044           1 :         char *pszOut = CPLUTF8ForceToASCII("foo\xc2\x80", '_');
    5045           1 :         EXPECT_STREQ(pszOut, "foo_");
    5046           1 :         CPLFree(pszOut);
    5047             :     }
    5048             :     {
    5049           1 :         char *pszOut = CPLUTF8ForceToASCII("foo\xc2\x80x", '_');
    5050           1 :         EXPECT_STREQ(pszOut, "foo_x");
    5051           1 :         CPLFree(pszOut);
    5052             :     }
    5053             :     {
    5054           1 :         std::string s;
    5055             :         {
    5056             :             VSILFILE *f =
    5057           1 :                 VSIFOpenL((data_ + SEP + "utf8accents.txt").c_str(), "rb");
    5058           1 :             ASSERT_NE(f, nullptr);
    5059           1 :             VSIFSeekL(f, 0, SEEK_END);
    5060           1 :             s.resize(static_cast<size_t>(VSIFTellL(f)));
    5061           1 :             VSIFSeekL(f, 0, SEEK_SET);
    5062           1 :             VSIFReadL(&s[0], 1, s.size(), f);
    5063           1 :             VSIFCloseL(f);
    5064           2 :             while (!s.empty() && s.back() == '\n')
    5065           1 :                 s.pop_back();
    5066             :         }
    5067           1 :         std::string sRef;
    5068             :         {
    5069           1 :             VSILFILE *f = VSIFOpenL(
    5070           2 :                 (data_ + SEP + "utf8accents_ascii.txt").c_str(), "rb");
    5071           1 :             ASSERT_NE(f, nullptr);
    5072           1 :             VSIFSeekL(f, 0, SEEK_END);
    5073           1 :             sRef.resize(static_cast<size_t>(VSIFTellL(f)));
    5074           1 :             VSIFSeekL(f, 0, SEEK_SET);
    5075           1 :             VSIFReadL(&sRef[0], 1, sRef.size(), f);
    5076           1 :             VSIFCloseL(f);
    5077           2 :             while (!sRef.empty() && sRef.back() == '\n')
    5078           1 :                 sRef.pop_back();
    5079             :         }
    5080           1 :         char *pszOut = CPLUTF8ForceToASCII(s.c_str(), '_');
    5081           1 :         EXPECT_STREQ(pszOut, sRef.c_str());
    5082           1 :         CPLFree(pszOut);
    5083             :     }
    5084             : }
    5085             : 
    5086             : #ifndef _WIN32
    5087           4 : TEST_F(test_cpl, CPLSpawn)
    5088             : {
    5089             :     VSIStatBufL sStatBuf;
    5090           1 :     if (VSIStatL("/bin/true", &sStatBuf) == 0)
    5091             :     {
    5092           1 :         const char *const apszArgs[] = {"/bin/true", nullptr};
    5093           1 :         EXPECT_EQ(CPLSpawn(apszArgs, nullptr, nullptr, false), 0);
    5094             :     }
    5095           1 :     if (VSIStatL("/bin/false", &sStatBuf) == 0)
    5096             :     {
    5097           1 :         const char *const apszArgs[] = {"/bin/false", nullptr};
    5098           1 :         EXPECT_EQ(CPLSpawn(apszArgs, nullptr, nullptr, false), 1);
    5099             :     }
    5100             : 
    5101             :     {
    5102           1 :         const char *const apszArgs[] = {"/i_do/not/exist", nullptr};
    5103           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
    5104           1 :         EXPECT_EQ(CPLSpawn(apszArgs, nullptr, nullptr, false), -1);
    5105           1 :         CPLPopErrorHandler();
    5106             :     }
    5107           1 : }
    5108             : #endif
    5109             : 
    5110           2 : static bool ENDS_WITH(const char *pszStr, const char *pszEnd)
    5111             : {
    5112           4 :     return strlen(pszStr) >= strlen(pszEnd) &&
    5113           4 :            strcmp(pszStr + strlen(pszStr) - strlen(pszEnd), pszEnd) == 0;
    5114             : }
    5115             : 
    5116           4 : TEST_F(test_cpl, VSIMemGenerateHiddenFilename)
    5117             : {
    5118             :     {
    5119             :         // Initial cleanup
    5120           1 :         VSIRmdirRecursive("/vsimem/");
    5121           1 :         VSIRmdirRecursive("/vsimem/.#!HIDDEN!#.");
    5122             : 
    5123             :         // Generate unlisted filename
    5124           2 :         const std::string osFilename1 = VSIMemGenerateHiddenFilename(nullptr);
    5125           1 :         const char *pszFilename1 = osFilename1.c_str();
    5126           1 :         EXPECT_TRUE(STARTS_WITH(pszFilename1, "/vsimem/.#!HIDDEN!#./"));
    5127           1 :         EXPECT_TRUE(ENDS_WITH(pszFilename1, "/unnamed"));
    5128             : 
    5129             :         {
    5130             :             // Check the file doesn't exist yet
    5131             :             VSIStatBufL sStat;
    5132           1 :             EXPECT_EQ(VSIStatL(pszFilename1, &sStat), -1);
    5133             :         }
    5134             : 
    5135             :         // Create the file with some content
    5136           1 :         GByte abyDummyData[1] = {0};
    5137           1 :         VSIFCloseL(VSIFileFromMemBuffer(pszFilename1, abyDummyData,
    5138             :                                         sizeof(abyDummyData), false));
    5139             : 
    5140             :         {
    5141             :             // Check the file exists now
    5142             :             VSIStatBufL sStat;
    5143           1 :             EXPECT_EQ(VSIStatL(pszFilename1, &sStat), 0);
    5144             :         }
    5145             : 
    5146             :         // Gets back content
    5147           1 :         EXPECT_EQ(VSIGetMemFileBuffer(pszFilename1, nullptr, false),
    5148             :                   abyDummyData);
    5149             : 
    5150             :         {
    5151             :             // Check the hidden file doesn't popup
    5152           2 :             const CPLStringList aosFiles(VSIReadDir("/vsimem/"));
    5153           1 :             EXPECT_EQ(aosFiles.size(), 0);
    5154             :         }
    5155             : 
    5156             :         {
    5157             :             // Check that we can list the below directory if we know it exists
    5158             :             // and there's just one subdir
    5159           2 :             const CPLStringList aosFiles(VSIReadDir("/vsimem/.#!HIDDEN!#."));
    5160           1 :             EXPECT_EQ(aosFiles.size(), 1);
    5161             :         }
    5162             : 
    5163             :         {
    5164             :             // but that it is not an explicit directory
    5165             :             VSIStatBufL sStat;
    5166           1 :             EXPECT_EQ(VSIStatL("/vsimem/.#!HIDDEN!#.", &sStat), -1);
    5167             :         }
    5168             : 
    5169             :         // Creates second file
    5170           2 :         const std::string osFilename2 = VSIMemGenerateHiddenFilename(nullptr);
    5171           1 :         const char *pszFilename2 = osFilename2.c_str();
    5172           1 :         EXPECT_TRUE(strcmp(pszFilename1, pszFilename2) != 0);
    5173             : 
    5174             :         // Create it
    5175           1 :         VSIFCloseL(VSIFileFromMemBuffer(pszFilename2, abyDummyData,
    5176             :                                         sizeof(abyDummyData), false));
    5177             : 
    5178             :         {
    5179             :             // Check that we can list the root hidden dir if we know it exists
    5180           2 :             const CPLStringList aosFiles(VSIReadDir("/vsimem/.#!HIDDEN!#."));
    5181           1 :             EXPECT_EQ(aosFiles.size(), 2);
    5182             :         }
    5183             : 
    5184             :         {
    5185             :             // Create an explicit subdirectory in a hidden directory
    5186             :             const std::string osBaseName =
    5187           2 :                 VSIMemGenerateHiddenFilename(nullptr);
    5188             :             const std::string osSubDir =
    5189           2 :                 CPLFormFilename(osBaseName.c_str(), "mysubdir", nullptr);
    5190           1 :             EXPECT_EQ(VSIMkdir(osSubDir.c_str(), 0), 0);
    5191             : 
    5192             :             // Check the subdirectory exists
    5193             :             {
    5194             :                 VSIStatBufL sStat;
    5195           1 :                 EXPECT_EQ(VSIStatL(osSubDir.c_str(), &sStat), 0);
    5196             :             }
    5197             : 
    5198             :             // but not its hidden parent
    5199             :             {
    5200             :                 VSIStatBufL sStat;
    5201           1 :                 EXPECT_EQ(VSIStatL(osBaseName.c_str(), &sStat), -1);
    5202             :             }
    5203             : 
    5204             :             // Create file within the subdirectory
    5205           1 :             VSIFCloseL(VSIFileFromMemBuffer(
    5206             :                 CPLFormFilename(osSubDir.c_str(), "my.bin", nullptr),
    5207             :                 abyDummyData, sizeof(abyDummyData), false));
    5208             : 
    5209             :             {
    5210             :                 // Check that we can list the subdirectory
    5211           2 :                 const CPLStringList aosFiles(VSIReadDir(osSubDir.c_str()));
    5212           1 :                 EXPECT_EQ(aosFiles.size(), 1);
    5213             :             }
    5214             : 
    5215             :             {
    5216             :                 // Check that we can list the root hidden dir if we know it exists
    5217             :                 const CPLStringList aosFiles(
    5218           2 :                     VSIReadDir("/vsimem/.#!HIDDEN!#."));
    5219           1 :                 EXPECT_EQ(aosFiles.size(), 3);
    5220             :             }
    5221             :         }
    5222             : 
    5223             :         // Directly create a directory with the return of VSIMemGenerateHiddenFilename()
    5224             :         {
    5225           2 :             const std::string osDirname = VSIMemGenerateHiddenFilename(nullptr);
    5226           1 :             EXPECT_EQ(VSIMkdir(osDirname.c_str(), 0), 0);
    5227             : 
    5228             :             // Check the subdirectory exists
    5229             :             {
    5230             :                 VSIStatBufL sStat;
    5231           1 :                 EXPECT_EQ(VSIStatL(osDirname.c_str(), &sStat), 0);
    5232             :             }
    5233             : 
    5234             :             // Create file within the subdirectory
    5235           1 :             VSIFCloseL(VSIFileFromMemBuffer(
    5236             :                 CPLFormFilename(osDirname.c_str(), "my.bin", nullptr),
    5237             :                 abyDummyData, sizeof(abyDummyData), false));
    5238             : 
    5239             :             {
    5240             :                 // Check there's a file in this subdirectory
    5241           2 :                 const CPLStringList aosFiles(VSIReadDir(osDirname.c_str()));
    5242           1 :                 EXPECT_EQ(aosFiles.size(), 1);
    5243             :             }
    5244             : 
    5245           1 :             EXPECT_EQ(VSIRmdirRecursive(osDirname.c_str()), 0);
    5246             : 
    5247             :             {
    5248             :                 // Check there's no longer any file in this subdirectory
    5249           2 :                 const CPLStringList aosFiles(VSIReadDir(osDirname.c_str()));
    5250           1 :                 EXPECT_EQ(aosFiles.size(), 0);
    5251             :             }
    5252             : 
    5253             :             {
    5254             :                 // Check that it no longer exists
    5255             :                 VSIStatBufL sStat;
    5256           1 :                 EXPECT_EQ(VSIStatL(osDirname.c_str(), &sStat), -1);
    5257             :             }
    5258             :         }
    5259             : 
    5260             :         // Check that operations on "/vsimem/" do not interfere with hidden files
    5261             :         {
    5262             :             // Create regular file
    5263           1 :             VSIFCloseL(VSIFileFromMemBuffer("/vsimem/regular_file",
    5264             :                                             abyDummyData, sizeof(abyDummyData),
    5265             :                                             false));
    5266             : 
    5267             :             // Check it is visible
    5268           1 :             EXPECT_EQ(CPLStringList(VSIReadDir("/vsimem/")).size(), 1);
    5269             : 
    5270             :             // Clean root /vsimem/
    5271           1 :             VSIRmdirRecursive("/vsimem/");
    5272             : 
    5273             :             // No more user files
    5274           1 :             EXPECT_TRUE(CPLStringList(VSIReadDir("/vsimem/")).empty());
    5275             : 
    5276             :             // But still hidden files
    5277           1 :             EXPECT_TRUE(
    5278             :                 !CPLStringList(VSIReadDir("/vsimem/.#!HIDDEN!#.")).empty());
    5279             :         }
    5280             : 
    5281             :         // Clean-up hidden files
    5282           1 :         EXPECT_EQ(VSIRmdirRecursive("/vsimem/.#!HIDDEN!#."), 0);
    5283             : 
    5284             :         {
    5285             :             // Check the root hidden dir is empty
    5286           2 :             const CPLStringList aosFiles(VSIReadDir("/vsimem/.#!HIDDEN!#."));
    5287           1 :             EXPECT_TRUE(aosFiles.empty());
    5288             :         }
    5289             : 
    5290           1 :         EXPECT_EQ(VSIRmdirRecursive("/vsimem/.#!HIDDEN!#."), 0);
    5291             :     }
    5292             : 
    5293             :     {
    5294           2 :         const std::string osFilename = VSIMemGenerateHiddenFilename("foo.bar");
    5295           1 :         const char *pszFilename = osFilename.c_str();
    5296           1 :         EXPECT_TRUE(STARTS_WITH(pszFilename, "/vsimem/.#!HIDDEN!#./"));
    5297           1 :         EXPECT_TRUE(ENDS_WITH(pszFilename, "/foo.bar"));
    5298             :     }
    5299           1 : }
    5300             : 
    5301           4 : TEST_F(test_cpl, VSIGlob)
    5302             : {
    5303           1 :     GByte abyDummyData[1] = {0};
    5304           1 :     const std::string osFilenameRadix = VSIMemGenerateHiddenFilename("");
    5305           1 :     const std::string osFilename = osFilenameRadix + "trick";
    5306           1 :     VSIFCloseL(VSIFileFromMemBuffer(osFilename.c_str(), abyDummyData,
    5307             :                                     sizeof(abyDummyData), false));
    5308             : 
    5309             :     {
    5310             :         CPLStringList aosRes(
    5311           1 :             VSIGlob(osFilename.c_str(), nullptr, nullptr, nullptr));
    5312           1 :         ASSERT_EQ(aosRes.size(), 1);
    5313           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5314             :     }
    5315             : 
    5316             :     {
    5317             :         CPLStringList aosRes(
    5318           1 :             VSIGlob(osFilename.substr(0, osFilename.size() - 1).c_str(),
    5319           1 :                     nullptr, nullptr, nullptr));
    5320           1 :         ASSERT_EQ(aosRes.size(), 0);
    5321             :     }
    5322             : 
    5323             :     {
    5324             :         CPLStringList aosRes(
    5325           1 :             VSIGlob(std::string(osFilenameRadix).append("?rick").c_str(),
    5326           1 :                     nullptr, nullptr, nullptr));
    5327           1 :         ASSERT_EQ(aosRes.size(), 1);
    5328           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5329             :     }
    5330             : 
    5331             :     {
    5332             :         CPLStringList aosRes(
    5333           1 :             VSIGlob(std::string(osFilenameRadix).append("?rack").c_str(),
    5334           1 :                     nullptr, nullptr, nullptr));
    5335           1 :         ASSERT_EQ(aosRes.size(), 0);
    5336             :     }
    5337             : 
    5338             :     {
    5339             :         CPLStringList aosRes(
    5340           1 :             VSIGlob(std::string(osFilenameRadix).append("*ick").c_str(),
    5341           1 :                     nullptr, nullptr, nullptr));
    5342           1 :         ASSERT_EQ(aosRes.size(), 1);
    5343           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5344             :     }
    5345             : 
    5346             :     {
    5347             :         CPLStringList aosRes(
    5348           1 :             VSIGlob(std::string(osFilenameRadix).append("*").c_str(), nullptr,
    5349           1 :                     nullptr, nullptr));
    5350           1 :         ASSERT_EQ(aosRes.size(), 1);
    5351           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5352             :     }
    5353             : 
    5354             :     {
    5355             :         CPLStringList aosRes(
    5356           1 :             VSIGlob(std::string(osFilenameRadix).append("*ack").c_str(),
    5357           1 :                     nullptr, nullptr, nullptr));
    5358           1 :         ASSERT_EQ(aosRes.size(), 0);
    5359             :     }
    5360             : 
    5361             :     {
    5362             :         CPLStringList aosRes(
    5363           1 :             VSIGlob(std::string(osFilenameRadix).append("*ic*").c_str(),
    5364           1 :                     nullptr, nullptr, nullptr));
    5365           1 :         ASSERT_EQ(aosRes.size(), 1);
    5366           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5367             :     }
    5368             : 
    5369             :     {
    5370             :         CPLStringList aosRes(
    5371           1 :             VSIGlob(std::string(osFilenameRadix).append("*ac*").c_str(),
    5372           1 :                     nullptr, nullptr, nullptr));
    5373           1 :         ASSERT_EQ(aosRes.size(), 0);
    5374             :     }
    5375             : 
    5376             :     {
    5377             :         CPLStringList aosRes(VSIGlob(
    5378           1 :             std::string(osFilenameRadix).append("[st][!s]ic[j-l]").c_str(),
    5379           1 :             nullptr, nullptr, nullptr));
    5380           1 :         ASSERT_EQ(aosRes.size(), 1);
    5381           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5382             :     }
    5383             : 
    5384             :     {
    5385             :         CPLStringList aosRes(
    5386           1 :             VSIGlob(std::string(osFilenameRadix).append("[!s]rick").c_str(),
    5387           1 :                     nullptr, nullptr, nullptr));
    5388           1 :         ASSERT_EQ(aosRes.size(), 1);
    5389           1 :         EXPECT_STREQ(aosRes[0], osFilename.c_str());
    5390             :     }
    5391             : 
    5392             :     {
    5393             :         CPLStringList aosRes(
    5394           1 :             VSIGlob(std::string(osFilenameRadix).append("[").c_str(), nullptr,
    5395           1 :                     nullptr, nullptr));
    5396           1 :         ASSERT_EQ(aosRes.size(), 0);
    5397             :     }
    5398             : 
    5399           1 :     const std::string osFilenameWithSpecialChars = osFilenameRadix + "[!-]";
    5400           1 :     VSIFCloseL(VSIFileFromMemBuffer(osFilenameWithSpecialChars.c_str(),
    5401             :                                     abyDummyData, sizeof(abyDummyData), false));
    5402             : 
    5403             :     {
    5404             :         CPLStringList aosRes(VSIGlob(
    5405           1 :             std::string(osFilenameRadix).append("[[][!]a-][-][]]").c_str(),
    5406           1 :             nullptr, nullptr, nullptr));
    5407           1 :         ASSERT_EQ(aosRes.size(), 1);
    5408           1 :         EXPECT_STREQ(aosRes[0], osFilenameWithSpecialChars.c_str());
    5409             :     }
    5410             : 
    5411           1 :     const std::string osFilename2 = osFilenameRadix + "truck/track";
    5412           1 :     VSIFCloseL(VSIFileFromMemBuffer(osFilename2.c_str(), abyDummyData,
    5413             :                                     sizeof(abyDummyData), false));
    5414             : 
    5415             :     {
    5416             :         CPLStringList aosRes(
    5417           1 :             VSIGlob(std::string(osFilenameRadix).append("*uc*/track").c_str(),
    5418           1 :                     nullptr, nullptr, nullptr));
    5419           1 :         ASSERT_EQ(aosRes.size(), 1);
    5420           1 :         EXPECT_STREQ(aosRes[0], osFilename2.c_str());
    5421             :     }
    5422             : 
    5423             :     {
    5424             :         CPLStringList aosRes(
    5425           1 :             VSIGlob(std::string(osFilenameRadix).append("*uc*/truck").c_str(),
    5426           1 :                     nullptr, nullptr, nullptr));
    5427           1 :         ASSERT_EQ(aosRes.size(), 0);
    5428             :     }
    5429             : 
    5430             :     {
    5431             :         CPLStringList aosRes(
    5432           1 :             VSIGlob(std::string(osFilenameRadix).append("**/track").c_str(),
    5433           1 :                     nullptr, nullptr, nullptr));
    5434           1 :         ASSERT_EQ(aosRes.size(), 1);
    5435           1 :         EXPECT_STREQ(aosRes[0], osFilename2.c_str());
    5436             :     }
    5437             : 
    5438           1 :     VSIUnlink(osFilename.c_str());
    5439           1 :     VSIUnlink(osFilenameWithSpecialChars.c_str());
    5440           1 :     VSIUnlink(osFilename2.c_str());
    5441           1 :     VSIUnlink(osFilenameRadix.c_str());
    5442             : 
    5443             : #if !defined(_WIN32)
    5444             :     {
    5445           1 :         std::string osCurDir;
    5446           1 :         osCurDir.resize(4096);
    5447           1 :         getcwd(&osCurDir[0], osCurDir.size());
    5448           1 :         osCurDir.resize(strlen(osCurDir.c_str()));
    5449           1 :         ASSERT_EQ(chdir(TUT_ROOT_DATA_DIR), 0);
    5450           1 :         CPLStringList aosRes(VSIGlob("byte*.tif", nullptr, nullptr, nullptr));
    5451           1 :         chdir(osCurDir.c_str());
    5452           1 :         ASSERT_EQ(aosRes.size(), 1);
    5453           1 :         EXPECT_STREQ(aosRes[0], "byte.tif");
    5454             :     }
    5455             : #endif
    5456             : }
    5457             : 
    5458           4 : TEST_F(test_cpl, CPLGreatestCommonDivisor)
    5459             : {
    5460           2 :     CPLErrorStateBackuper state(CPLQuietErrorHandler);
    5461             : 
    5462             :     // These tests serve to document the current behavior.
    5463             :     // In some cases the results are dependent on various
    5464             :     // hardcoded epsilons and it may be appropriate to change
    5465             :     // the expected results.
    5466             : 
    5467           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(0.0, 1.0), 0.0);
    5468           1 :     EXPECT_EQ(
    5469             :         CPLGreatestCommonDivisor(std::numeric_limits<double>::quiet_NaN(), 1.0),
    5470             :         0.0);
    5471           1 :     EXPECT_EQ(
    5472             :         CPLGreatestCommonDivisor(std::numeric_limits<double>::infinity(), 1.0),
    5473             :         0.0);
    5474           1 :     EXPECT_EQ(
    5475             :         CPLGreatestCommonDivisor(-std::numeric_limits<double>::infinity(), 1.0),
    5476             :         0.0);
    5477           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(1.0, 0.0), 0.0);
    5478           1 :     EXPECT_EQ(
    5479             :         CPLGreatestCommonDivisor(1.0, std::numeric_limits<double>::quiet_NaN()),
    5480             :         0.0);
    5481           1 :     EXPECT_EQ(
    5482             :         CPLGreatestCommonDivisor(1.0, std::numeric_limits<double>::infinity()),
    5483             :         0.0);
    5484           1 :     EXPECT_EQ(
    5485             :         CPLGreatestCommonDivisor(1.0, -std::numeric_limits<double>::infinity()),
    5486             :         0.0);
    5487             : 
    5488           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(std::numeric_limits<double>::min(),
    5489             :                                        std::numeric_limits<double>::max()),
    5490             :               0.0);
    5491             : 
    5492           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(-2.0, 4.0), -2.0);
    5493           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(-2.0, -4.0), -2.0);
    5494           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(2.0, -4.0), 2.0);
    5495             : 
    5496           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(3.0, 5.0), 1.0);
    5497           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(3.0 / 3600, 5.0 / 3600), 1.0 / 3600);
    5498           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(5.0 / 3600, 2.5 / 3600), 2.5 / 3600);
    5499           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(1.0 / 10, 1.0), 1.0 / 10);
    5500           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(1.0 / 17, 1.0 / 13), 1.0 / 221);
    5501           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(1.0 / 17, 1.0 / 3600), 1.0 / 61200);
    5502             : 
    5503             :     // GLO-90 resolutoins
    5504           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(3.0 / 3600, 4.5 / 3600), 1.5 / 3600);
    5505             : 
    5506             :     // WorldDEM resolutions
    5507           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(0.4 / 3600, 0.6 / 3600), 0.2 / 3600);
    5508           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(0.6 / 3600, 0.8 / 3600), 0.2 / 3600);
    5509             : 
    5510           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(M_PI, M_PI / 6), M_PI / 6);
    5511           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(M_PI / 5, M_PI / 6),
    5512             :               0);  // Ideally we would get M_PI / 30
    5513             : 
    5514           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(2.999999, 3.0), 0);
    5515           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(2.9999999, 3.0), 0);
    5516           1 :     EXPECT_EQ(CPLGreatestCommonDivisor(2.99999999, 3.0), 2.99999999);
    5517           1 : }
    5518             : 
    5519           4 : TEST_F(test_cpl, CPLLevenshteinDistance)
    5520             : {
    5521           1 :     EXPECT_EQ(CPLLevenshteinDistance("", "", false), 0);
    5522           1 :     EXPECT_EQ(CPLLevenshteinDistance("a", "a", false), 0);
    5523           1 :     EXPECT_EQ(CPLLevenshteinDistance("a", "b", false), 1);
    5524           1 :     EXPECT_EQ(CPLLevenshteinDistance("a", "", false), 1);
    5525           1 :     EXPECT_EQ(CPLLevenshteinDistance("abc", "ac", false), 1);
    5526           1 :     EXPECT_EQ(CPLLevenshteinDistance("ac", "abc", false), 1);
    5527           1 :     EXPECT_EQ(CPLLevenshteinDistance("0ab1", "0xy1", false), 2);
    5528           1 :     EXPECT_EQ(CPLLevenshteinDistance("0ab1", "0xy1", true), 2);
    5529           1 :     EXPECT_EQ(CPLLevenshteinDistance("0ab1", "0ba1", false), 2);
    5530           1 :     EXPECT_EQ(CPLLevenshteinDistance("0ab1", "0ba1", true), 1);
    5531             : 
    5532           2 :     std::string longStr(32768, 'x');
    5533           1 :     EXPECT_EQ(CPLLevenshteinDistance(longStr.c_str(), longStr.c_str(), true),
    5534             :               0);
    5535           1 :     EXPECT_EQ(CPLLevenshteinDistance(longStr.c_str(), "another_one", true),
    5536             :               std::numeric_limits<size_t>::max());
    5537           1 : }
    5538             : 
    5539           4 : TEST_F(test_cpl, CPLLockFileEx)
    5540             : {
    5541           1 :     const std::string osLockFilename = CPLGenerateTempFilename(".lock");
    5542             : 
    5543           1 :     ASSERT_EQ(CPLLockFileEx(nullptr, nullptr, nullptr), CLFS_API_MISUSE);
    5544             : 
    5545           1 :     ASSERT_EQ(CPLLockFileEx(osLockFilename.c_str(), nullptr, nullptr),
    5546             :               CLFS_API_MISUSE);
    5547             : 
    5548           1 :     CPLLockFileHandle hLockFileHandle = nullptr;
    5549             : 
    5550           1 :     ASSERT_EQ(CPLLockFileEx(osLockFilename.c_str(), &hLockFileHandle, nullptr),
    5551             :               CLFS_OK);
    5552           1 :     ASSERT_NE(hLockFileHandle, nullptr);
    5553             : 
    5554             :     // Check the lock file has been created
    5555             :     VSIStatBufL sStat;
    5556           1 :     ASSERT_EQ(VSIStatL(osLockFilename.c_str(), &sStat), 0);
    5557             : 
    5558             :     {
    5559           1 :         CPLStringList aosOptions;
    5560           1 :         aosOptions.SetNameValue("WAIT_TIME", "0.1");
    5561           1 :         CPLLockFileHandle hLockFileHandle2 = nullptr;
    5562           1 :         ASSERT_EQ(CPLLockFileEx(osLockFilename.c_str(), &hLockFileHandle2,
    5563             :                                 aosOptions.List()),
    5564             :                   CLFS_LOCK_BUSY);
    5565             :     }
    5566             : 
    5567           1 :     CPLUnlockFileEx(hLockFileHandle);
    5568             : 
    5569             :     // Check the lock file has been deleted
    5570           1 :     ASSERT_EQ(VSIStatL(osLockFilename.c_str(), &sStat), -1);
    5571             : 
    5572           1 :     CPLUnlockFileEx(nullptr);
    5573             : }
    5574             : 
    5575           4 : TEST_F(test_cpl, CPLFormatReadableFileSize)
    5576             : {
    5577           2 :     EXPECT_STREQ(CPLFormatReadableFileSize(1.23e18).c_str(), "1.23 HB");
    5578           2 :     EXPECT_STREQ(CPLFormatReadableFileSize(1.23e15).c_str(), "1.23 PB");
    5579           2 :     EXPECT_STREQ(CPLFormatReadableFileSize(1.23e12).c_str(), "1.23 TB");
    5580           2 :     EXPECT_STREQ(CPLFormatReadableFileSize(1.23e9).c_str(), "1.23 GB");
    5581           2 :     EXPECT_STREQ(CPLFormatReadableFileSize(1.23e6).c_str(), "1.23 MB");
    5582           2 :     EXPECT_STREQ(
    5583             :         CPLFormatReadableFileSize(static_cast<uint64_t>(123456)).c_str(),
    5584             :         "123,456 bytes");
    5585           1 : }
    5586             : 
    5587           4 : TEST_F(test_cpl, CPLStrlenUTF8)
    5588             : {
    5589           1 :     EXPECT_EQ(CPLStrlenUTF8("a"), 1);
    5590           1 :     EXPECT_EQ(CPLStrlenUTF8("a"
    5591             :                             "\xC3\xA9"
    5592             :                             "b"),
    5593             :               3);
    5594           1 : }
    5595             : 
    5596           4 : TEST_F(test_cpl, CPLStrlenUTF8Ex)
    5597             : {
    5598           1 :     EXPECT_EQ(CPLStrlenUTF8Ex("a"), 1);
    5599           1 :     EXPECT_EQ(CPLStrlenUTF8Ex("a"
    5600             :                               "\xC3\xA9"
    5601             :                               "b"),
    5602             :               3);
    5603           1 : }
    5604             : 
    5605           4 : TEST_F(test_cpl, CPLGetRemainingFileDescriptorCount)
    5606             : {
    5607             : #ifdef _WIN32
    5608             :     EXPECT_EQ(CPLGetRemainingFileDescriptorCount(), -1);
    5609             : #else
    5610           1 :     EXPECT_GE(CPLGetRemainingFileDescriptorCount(), 0);
    5611             : #endif
    5612           1 : }
    5613             : 
    5614           4 : TEST_F(test_cpl, CPLGetCurrentThreadCount)
    5615             : {
    5616             : #if defined(_WIN32) || defined(__linux) || defined(__FreeBSD__) ||             \
    5617             :     defined(__NetBSD__) || (defined(__APPLE__) && defined(__MACH__))
    5618             :     // Not sure why it returns 0 on those, whereas it works fine on build-windows-msys2-mingw
    5619           1 :     if (strstr(CPLGetConfigOption("BUILD_NAME", ""), "build-windows-conda") !=
    5620           1 :             nullptr &&
    5621           0 :         strstr(CPLGetConfigOption("BUILD_NAME", ""), "build-windows-minimum") !=
    5622             :             nullptr)
    5623             :     {
    5624           0 :         EXPECT_GE(CPLGetCurrentThreadCount(), 1);
    5625             :     }
    5626             : #else
    5627             :     EXPECT_EQ(CPLGetCurrentThreadCount(), 0);
    5628             : #endif
    5629           1 : }
    5630             : 
    5631           4 : TEST_F(test_cpl, CPLHasPathTraversal)
    5632             : {
    5633           1 :     EXPECT_TRUE(CPLHasPathTraversal("a/../b"));
    5634           1 :     EXPECT_TRUE(CPLHasPathTraversal("a/../"));
    5635           1 :     EXPECT_TRUE(CPLHasPathTraversal("a/.."));
    5636           1 :     EXPECT_TRUE(CPLHasPathTraversal("a\\..\\b"));
    5637           1 :     EXPECT_FALSE(CPLHasPathTraversal("a/b"));
    5638             :     {
    5639             :         CPLConfigOptionSetter oSetter("CPL_ENABLE_PATH_TRAVERSAL_DETECTION",
    5640           2 :                                       "NO", true);
    5641           1 :         EXPECT_FALSE(CPLHasPathTraversal("a/../b"));
    5642           1 :         EXPECT_FALSE(CPLHasPathTraversal("a\\..\\b"));
    5643             :     }
    5644           1 : }
    5645             : 
    5646           4 : TEST_F(test_cpl, CPLHasUnbalancedPathTraversal)
    5647             : {
    5648           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a"));
    5649           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("."));
    5650           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("./"));
    5651           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a/.."));
    5652           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a/../b"));
    5653           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("./a/../b"));
    5654           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a\\..\\b"));
    5655           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a/../b/../"));
    5656           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a/../b/.."));
    5657           1 :     EXPECT_FALSE(CPLHasUnbalancedPathTraversal("a/b"));
    5658             : 
    5659           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal(".."));
    5660           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("../"));
    5661           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("../b"));
    5662           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("a/../../"));
    5663           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("a/../b/../.."));
    5664           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("a/../b/../../"));
    5665           1 :     EXPECT_TRUE(CPLHasUnbalancedPathTraversal("a\\..\\..\\"));
    5666           1 : }
    5667             : 
    5668             : }  // namespace

Generated by: LCOV version 1.14