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

Generated by: LCOV version 1.14