LCOV - code coverage report
Current view: top level - autotest/cpp - test_ogr.cpp (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 2722 2739 99.4 %
Date: 2025-09-10 17:48:50 Functions: 372 372 100.0 %

          Line data    Source code
       1             : ///////////////////////////////////////////////////////////////////////////////
       2             : //
       3             : // Project:  C++ Test Suite for GDAL/OGR
       4             : // Purpose:  Test general OGR features.
       5             : // Author:   Mateusz Loskot <mateusz@loskot.net>
       6             : //
       7             : ///////////////////////////////////////////////////////////////////////////////
       8             : // Copyright (c) 2006, Mateusz Loskot <mateusz@loskot.net>
       9             : /*
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #include "gdal_unit_test.h"
      14             : 
      15             : #include "ogr_p.h"
      16             : #include "ogrsf_frmts.h"
      17             : #include "../../ogr/ogrsf_frmts/osm/gpb.h"
      18             : #include "ogr_recordbatch.h"
      19             : #include "ogrlayerarrow.h"
      20             : 
      21             : #include <string>
      22             : #include <algorithm>
      23             : #include <cmath>
      24             : #include <fstream>
      25             : #include <limits>
      26             : 
      27             : #ifdef HAVE_SQLITE3
      28             : #include <sqlite3.h>
      29             : #endif
      30             : 
      31             : #include "gtest_include.h"
      32             : 
      33             : namespace
      34             : {
      35             : 
      36             : // Common fixture with test data
      37             : struct test_ogr : public ::testing::Test
      38             : {
      39             :     std::string data_{tut::common::data_basedir};
      40             :     std::string data_tmp_{tut::common::tmp_basedir};
      41             : };
      42             : 
      43             : // Test OGR driver registrar access
      44           4 : TEST_F(test_ogr, GetGDALDriverManager)
      45             : {
      46           1 :     ASSERT_TRUE(nullptr != GetGDALDriverManager());
      47             : }
      48             : 
      49             : template <class T>
      50          16 : void testSpatialReferenceLeakOnCopy(OGRSpatialReference *poSRS)
      51             : {
      52          16 :     ASSERT_EQ(1, poSRS->GetReferenceCount());
      53             :     {
      54             :         int nCurCount;
      55          16 :         int nLastCount = 1;
      56          16 :         T value;
      57          16 :         value.assignSpatialReference(poSRS);
      58          16 :         nCurCount = poSRS->GetReferenceCount();
      59          16 :         ASSERT_GT(nCurCount, nLastCount);
      60          16 :         nLastCount = nCurCount;
      61             : 
      62          16 :         T value2(value);
      63          16 :         nCurCount = poSRS->GetReferenceCount();
      64          16 :         ASSERT_GT(nCurCount, nLastCount);
      65          16 :         nLastCount = nCurCount;
      66             : 
      67          16 :         T value3;
      68          16 :         value3 = value;
      69          16 :         nCurCount = poSRS->GetReferenceCount();
      70          16 :         ASSERT_GT(nCurCount, nLastCount);
      71          16 :         nLastCount = nCurCount;
      72             : 
      73          16 :         value3 = value;
      74             :         // avoid Coverity Scan warning about above assignment being better
      75             :         // replaced with a move.
      76          16 :         EXPECT_NE(value.getSpatialReference(), nullptr);
      77          16 :         ASSERT_EQ(nLastCount, poSRS->GetReferenceCount());
      78             :     }
      79          16 :     ASSERT_EQ(1, poSRS->GetReferenceCount());
      80             : }
      81             : 
      82             : // Test if copy does not leak or double delete the spatial reference
      83           4 : TEST_F(test_ogr, SpatialReference_leak)
      84             : {
      85           1 :     OGRSpatialReference *poSRS = new OGRSpatialReference();
      86           1 :     ASSERT_TRUE(nullptr != poSRS);
      87             : 
      88           1 :     testSpatialReferenceLeakOnCopy<OGRPoint>(poSRS);
      89           1 :     testSpatialReferenceLeakOnCopy<OGRLineString>(poSRS);
      90           1 :     testSpatialReferenceLeakOnCopy<OGRLinearRing>(poSRS);
      91           1 :     testSpatialReferenceLeakOnCopy<OGRCircularString>(poSRS);
      92           1 :     testSpatialReferenceLeakOnCopy<OGRCompoundCurve>(poSRS);
      93           1 :     testSpatialReferenceLeakOnCopy<OGRCurvePolygon>(poSRS);
      94           1 :     testSpatialReferenceLeakOnCopy<OGRPolygon>(poSRS);
      95           1 :     testSpatialReferenceLeakOnCopy<OGRGeometryCollection>(poSRS);
      96           1 :     testSpatialReferenceLeakOnCopy<OGRMultiSurface>(poSRS);
      97           1 :     testSpatialReferenceLeakOnCopy<OGRMultiPolygon>(poSRS);
      98           1 :     testSpatialReferenceLeakOnCopy<OGRMultiPoint>(poSRS);
      99           1 :     testSpatialReferenceLeakOnCopy<OGRMultiCurve>(poSRS);
     100           1 :     testSpatialReferenceLeakOnCopy<OGRMultiLineString>(poSRS);
     101           1 :     testSpatialReferenceLeakOnCopy<OGRTriangle>(poSRS);
     102           1 :     testSpatialReferenceLeakOnCopy<OGRPolyhedralSurface>(poSRS);
     103           1 :     testSpatialReferenceLeakOnCopy<OGRTriangulatedSurface>(poSRS);
     104             : 
     105           1 :     delete poSRS;
     106             : 
     107             :     // Check that assignSpatialReference() works when passed the SRS
     108             :     // object it already owns and whose has a single reference.
     109           1 :     poSRS = new OGRSpatialReference();
     110           2 :     OGRPoint oPoint;
     111           1 :     oPoint.assignSpatialReference(poSRS);
     112           1 :     poSRS->Release();
     113           1 :     oPoint.assignSpatialReference(oPoint.getSpatialReference());
     114             : }
     115             : 
     116             : template <class T> T *make();
     117             : 
     118           6 : template <> OGRPoint *make()
     119             : {
     120           6 :     return new OGRPoint(1.0, 2.0, 3.0);
     121             : }
     122             : 
     123          18 : template <> OGRLineString *make()
     124             : {
     125          18 :     OGRLineString *poLineString = new OGRLineString();
     126             : 
     127          18 :     poLineString->addPoint(1.0, 2.0, 3.0);
     128          18 :     poLineString->addPoint(1.1, 2.1, 3.1);
     129          18 :     poLineString->addPoint(1.2, 2.2, 3.2);
     130             : 
     131          18 :     return poLineString;
     132             : }
     133             : 
     134          22 : template <> OGRLinearRing *make()
     135             : {
     136          22 :     OGRLinearRing *poLinearRing = new OGRLinearRing();
     137             : 
     138          22 :     poLinearRing->addPoint(1.0, 2.0, 3.0);
     139          22 :     poLinearRing->addPoint(1.1, 2.1, 3.1);
     140          22 :     poLinearRing->addPoint(1.2, 2.2, 3.2);
     141          22 :     poLinearRing->addPoint(1.0, 2.0, 3.0);
     142             : 
     143          22 :     return poLinearRing;
     144             : }
     145             : 
     146          14 : template <> OGRCircularString *make()
     147             : {
     148          14 :     OGRCircularString *poCircularString = new OGRCircularString();
     149             : 
     150          14 :     poCircularString->addPoint(1.0, 2.0, 3.0);
     151          14 :     poCircularString->addPoint(1.1, 2.1, 3.1);
     152          14 :     poCircularString->addPoint(1.2, 2.2, 3.2);
     153             : 
     154          14 :     return poCircularString;
     155             : }
     156             : 
     157          12 : template <> OGRCompoundCurve *make()
     158             : {
     159          12 :     OGRCompoundCurve *poCompoundCurve = new OGRCompoundCurve();
     160             : 
     161          12 :     poCompoundCurve->addCurveDirectly(make<OGRLineString>());
     162          12 :     OGRCircularString *poCircularString = make<OGRCircularString>();
     163          12 :     poCircularString->reversePoints();
     164          12 :     poCompoundCurve->addCurveDirectly(poCircularString);
     165             : 
     166          12 :     return poCompoundCurve;
     167             : }
     168             : 
     169           4 : template <> OGRCurvePolygon *make()
     170             : {
     171           4 :     OGRCurvePolygon *poCurvePolygon = new OGRCurvePolygon();
     172             : 
     173           4 :     poCurvePolygon->addRingDirectly(make<OGRCompoundCurve>());
     174           4 :     poCurvePolygon->addRingDirectly(make<OGRCompoundCurve>());
     175             : 
     176           4 :     return poCurvePolygon;
     177             : }
     178             : 
     179           8 : template <> OGRPolygon *make()
     180             : {
     181           8 :     OGRPolygon *poPolygon = new OGRPolygon();
     182             : 
     183           8 :     poPolygon->addRingDirectly(make<OGRLinearRing>());
     184           8 :     poPolygon->addRingDirectly(make<OGRLinearRing>());
     185             : 
     186           8 :     return poPolygon;
     187             : }
     188             : 
     189           2 : template <> OGRGeometryCollection *make()
     190             : {
     191           2 :     OGRGeometryCollection *poCollection = new OGRGeometryCollection();
     192             : 
     193           2 :     poCollection->addGeometryDirectly(make<OGRPoint>());
     194           2 :     poCollection->addGeometryDirectly(make<OGRLinearRing>());
     195             : 
     196           2 :     return poCollection;
     197             : }
     198             : 
     199           2 : template <> OGRMultiSurface *make()
     200             : {
     201           2 :     OGRMultiSurface *poCollection = new OGRMultiSurface();
     202             : 
     203           2 :     poCollection->addGeometryDirectly(make<OGRPolygon>());
     204           2 :     poCollection->addGeometryDirectly(make<OGRCurvePolygon>());
     205             : 
     206           2 :     return poCollection;
     207             : }
     208             : 
     209           2 : template <> OGRMultiPolygon *make()
     210             : {
     211           2 :     OGRMultiPolygon *poCollection = new OGRMultiPolygon();
     212             : 
     213           2 :     poCollection->addGeometryDirectly(make<OGRPolygon>());
     214             : 
     215           2 :     return poCollection;
     216             : }
     217             : 
     218           2 : template <> OGRMultiPoint *make()
     219             : {
     220           2 :     OGRMultiPoint *poCollection = new OGRMultiPoint();
     221             : 
     222           2 :     poCollection->addGeometryDirectly(make<OGRPoint>());
     223             : 
     224           2 :     return poCollection;
     225             : }
     226             : 
     227           2 : template <> OGRMultiCurve *make()
     228             : {
     229           2 :     OGRMultiCurve *poCollection = new OGRMultiCurve();
     230             : 
     231           2 :     poCollection->addGeometryDirectly(make<OGRLineString>());
     232           2 :     poCollection->addGeometryDirectly(make<OGRCompoundCurve>());
     233             : 
     234           2 :     return poCollection;
     235             : }
     236             : 
     237           2 : template <> OGRMultiLineString *make()
     238             : {
     239           2 :     OGRMultiLineString *poCollection = new OGRMultiLineString();
     240             : 
     241           2 :     poCollection->addGeometryDirectly(make<OGRLineString>());
     242           2 :     poCollection->addGeometryDirectly(make<OGRLinearRing>());
     243             : 
     244           2 :     return poCollection;
     245             : }
     246             : 
     247           4 : template <> OGRTriangle *make()
     248             : {
     249           8 :     OGRPoint p1(0, 0), p2(0, 1), p3(1, 1);
     250           8 :     return new OGRTriangle(p1, p2, p3);
     251             : }
     252             : 
     253           2 : template <> OGRTriangulatedSurface *make()
     254             : {
     255           2 :     OGRTriangulatedSurface *poTS = new OGRTriangulatedSurface();
     256           2 :     poTS->addGeometryDirectly(make<OGRTriangle>());
     257           2 :     return poTS;
     258             : }
     259             : 
     260           2 : template <> OGRPolyhedralSurface *make()
     261             : {
     262           2 :     OGRPolyhedralSurface *poPS = new OGRPolyhedralSurface();
     263           2 :     poPS->addGeometryDirectly(make<OGRPolygon>());
     264           2 :     return poPS;
     265             : }
     266             : 
     267          16 : template <class T> void testCopyEquals()
     268             : {
     269          16 :     auto poOrigin = std::unique_ptr<T>(make<T>());
     270          16 :     ASSERT_TRUE(nullptr != poOrigin);
     271             : 
     272          16 :     T value2(*poOrigin);
     273             : 
     274          16 :     ASSERT_TRUE(CPL_TO_BOOL(poOrigin->Equals(&value2)))
     275           0 :         << poOrigin->getGeometryName() << ": copy constructor changed a value";
     276             : 
     277          16 :     T value3;
     278          16 :     value3 = *poOrigin;
     279          16 :     value3 = *poOrigin;
     280          16 :     auto &value3Ref(value3);
     281          16 :     value3 = value3Ref;
     282             : 
     283             : #ifdef DEBUG_VERBOSE
     284             :     char *wkt1 = NULL, *wkt2 = NULL;
     285             :     poOrigin->exportToWkt(&wkt1);
     286             :     value3.exportToWkt(&wkt2);
     287             :     printf("%s %s\n", wkt1, wkt2);
     288             :     CPLFree(wkt1);
     289             :     CPLFree(wkt2);
     290             : #endif
     291          16 :     ASSERT_TRUE(CPL_TO_BOOL(poOrigin->Equals(&value3)))
     292           0 :         << poOrigin->getGeometryName()
     293           0 :         << ": assignment operator changed a value";
     294             : 
     295          16 :     value3 = T();
     296          16 :     ASSERT_TRUE(value3.IsEmpty());
     297             : }
     298             : 
     299             : // Test if copy constructor and assignment operators succeeds on copying the
     300             : // geometry data
     301           4 : TEST_F(test_ogr, SpatialReference_leak_copy_constructor)
     302             : {
     303           1 :     testCopyEquals<OGRPoint>();
     304           1 :     testCopyEquals<OGRLineString>();
     305           1 :     testCopyEquals<OGRLinearRing>();
     306           1 :     testCopyEquals<OGRCircularString>();
     307           1 :     testCopyEquals<OGRCompoundCurve>();
     308           1 :     testCopyEquals<OGRCurvePolygon>();
     309           1 :     testCopyEquals<OGRPolygon>();
     310           1 :     testCopyEquals<OGRGeometryCollection>();
     311           1 :     testCopyEquals<OGRMultiSurface>();
     312           1 :     testCopyEquals<OGRMultiPolygon>();
     313           1 :     testCopyEquals<OGRMultiPoint>();
     314           1 :     testCopyEquals<OGRMultiCurve>();
     315           1 :     testCopyEquals<OGRMultiLineString>();
     316           1 :     testCopyEquals<OGRTriangle>();
     317           1 :     testCopyEquals<OGRPolyhedralSurface>();
     318           1 :     testCopyEquals<OGRTriangulatedSurface>();
     319           1 : }
     320             : 
     321             : // Test crazy usage of OGRGeometryCollection copy constructor
     322           4 : TEST_F(test_ogr, OGRGeometryCollection_copy_constructor_illegal_use)
     323             : {
     324           2 :     OGRGeometryCollection gc;
     325           1 :     gc.addGeometryDirectly(new OGRPoint(1, 2));
     326             : 
     327           2 :     OGRMultiPolygon mp;
     328           1 :     mp.addGeometryDirectly(new OGRPolygon());
     329             : 
     330           1 :     OGRGeometryCollection *mp_as_gc = &mp;
     331           1 :     CPLErrorReset();
     332             :     {
     333           2 :         CPLErrorHandlerPusher oPusher(CPLQuietErrorHandler);
     334           1 :         *mp_as_gc = gc;
     335             :         // avoid Coverity Scan warning
     336           1 :         EXPECT_EQ(gc.getSpatialReference(), nullptr);
     337             :     }
     338           1 :     EXPECT_STREQ(CPLGetLastErrorMsg(),
     339             :                  "Illegal use of OGRGeometryCollection::operator=(): trying to "
     340             :                  "assign an incompatible sub-geometry");
     341           1 :     EXPECT_TRUE(mp.IsEmpty());
     342           1 : }
     343             : 
     344             : // Test crazy usage of OGRCurvePolygon copy constructor
     345           4 : TEST_F(test_ogr, OGRCurvePolygon_copy_constructor_illegal_use)
     346             : {
     347           2 :     OGRCurvePolygon cp;
     348           1 :     auto poCC = new OGRCircularString();
     349           1 :     poCC->addPoint(0, 0);
     350           1 :     poCC->addPoint(1, 1);
     351           1 :     poCC->addPoint(2, 0);
     352           1 :     poCC->addPoint(1, -1);
     353           1 :     poCC->addPoint(0, 0);
     354           1 :     cp.addRingDirectly(poCC);
     355             : 
     356           2 :     OGRPolygon poly;
     357           1 :     auto poLR = new OGRLinearRing();
     358           1 :     poLR->addPoint(0, 0);
     359           1 :     poLR->addPoint(1, 1);
     360           1 :     poLR->addPoint(2, 0);
     361           1 :     poLR->addPoint(1, -1);
     362           1 :     poLR->addPoint(0, 0);
     363           1 :     poly.addRingDirectly(poLR);
     364             : 
     365           1 :     OGRCurvePolygon *poly_as_cp = &poly;
     366           1 :     CPLErrorReset();
     367             :     {
     368           2 :         CPLErrorHandlerPusher oPusher(CPLQuietErrorHandler);
     369           1 :         *poly_as_cp = cp;
     370             :         // avoid Coverity Scan warning
     371           1 :         EXPECT_EQ(cp.getSpatialReference(), nullptr);
     372             :     }
     373           1 :     EXPECT_STREQ(CPLGetLastErrorMsg(),
     374             :                  "Illegal use of OGRCurvePolygon::operator=(): trying to "
     375             :                  "assign an incompatible sub-geometry");
     376           1 :     EXPECT_TRUE(poly.IsEmpty());
     377           1 : }
     378             : 
     379          16 : template <class T> void testMove()
     380             : {
     381          16 :     auto poSRS = new OGRSpatialReference();
     382             :     {
     383          16 :         auto poOrigin = std::unique_ptr<T>(make<T>());
     384          16 :         ASSERT_TRUE(nullptr != poOrigin);
     385          16 :         poOrigin->assignSpatialReference(poSRS);
     386             : 
     387          16 :         T valueCopy(*poOrigin);
     388          16 :         const int refCountBefore = poSRS->GetReferenceCount();
     389          16 :         T fromMoved(std::move(*poOrigin));
     390          16 :         EXPECT_EQ(poSRS->GetReferenceCount(), refCountBefore);
     391             : 
     392          16 :         ASSERT_TRUE(CPL_TO_BOOL(fromMoved.Equals(&valueCopy)))
     393           0 :             << valueCopy.getGeometryName()
     394           0 :             << ": move constructor changed a value";
     395          16 :         EXPECT_EQ(fromMoved.getSpatialReference(), poSRS);
     396             : 
     397          16 :         T valueCopy2(valueCopy);
     398          16 :         EXPECT_EQ(valueCopy.getSpatialReference(), poSRS);
     399          16 :         T value3;
     400          16 :         const int refCountBefore2 = poSRS->GetReferenceCount();
     401          16 :         value3 = std::move(valueCopy);
     402          16 :         EXPECT_EQ(poSRS->GetReferenceCount(), refCountBefore2);
     403             : 
     404          16 :         ASSERT_TRUE(CPL_TO_BOOL(value3.Equals(&valueCopy2)))
     405           0 :             << valueCopy2.getGeometryName()
     406           0 :             << ": move assignment operator changed a value";
     407          16 :         EXPECT_EQ(value3.getSpatialReference(), poSRS);
     408             :     }
     409          16 :     EXPECT_EQ(poSRS->GetReferenceCount(), 1);
     410          16 :     poSRS->Release();
     411             : }
     412             : 
     413           4 : TEST_F(test_ogr, geometry_move)
     414             : {
     415           1 :     testMove<OGRPoint>();
     416           1 :     testMove<OGRLineString>();
     417           1 :     testMove<OGRLinearRing>();
     418           1 :     testMove<OGRCircularString>();
     419           1 :     testMove<OGRCompoundCurve>();
     420           1 :     testMove<OGRCurvePolygon>();
     421           1 :     testMove<OGRPolygon>();
     422           1 :     testMove<OGRGeometryCollection>();
     423           1 :     testMove<OGRMultiSurface>();
     424           1 :     testMove<OGRMultiPolygon>();
     425           1 :     testMove<OGRMultiPoint>();
     426           1 :     testMove<OGRMultiCurve>();
     427           1 :     testMove<OGRMultiLineString>();
     428           1 :     testMove<OGRTriangle>();
     429           1 :     testMove<OGRPolyhedralSurface>();
     430           1 :     testMove<OGRTriangulatedSurface>();
     431           1 : }
     432             : 
     433           4 : TEST_F(test_ogr, geometry_get_point)
     434             : {
     435             :     {
     436           1 :         OGRPoint p;
     437           1 :         double x = 1, y = 2;
     438           1 :         OGR_G_SetPoints((OGRGeometryH)&p, 1, &x, 0, &y, 0, nullptr, 0);
     439           1 :         ASSERT_EQ(p.getCoordinateDimension(), 2);
     440           1 :         ASSERT_EQ(p.getX(), 1);
     441           1 :         ASSERT_EQ(p.getY(), 2);
     442           1 :         ASSERT_EQ(p.getZ(), 0);
     443             :     }
     444             : 
     445             :     {
     446           1 :         OGRPoint p;
     447           1 :         double x = 1, y = 2, z = 3;
     448           1 :         OGR_G_SetPoints((OGRGeometryH)&p, 1, &x, 0, &y, 0, &z, 0);
     449           1 :         ASSERT_EQ(p.getCoordinateDimension(), 3);
     450           1 :         ASSERT_EQ(p.getX(), 1);
     451           1 :         ASSERT_EQ(p.getY(), 2);
     452           1 :         ASSERT_EQ(p.getZ(), 3);
     453             :     }
     454             : 
     455             :     {
     456           2 :         OGRPoint p;
     457           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
     458           1 :         OGR_G_SetPoints((OGRGeometryH)&p, 1, nullptr, 0, nullptr, 0, nullptr,
     459             :                         0);
     460           1 :         CPLPopErrorHandler();
     461             :     }
     462             : 
     463             :     {
     464           1 :         OGRLineString ls;
     465           1 :         double x = 1, y = 2;
     466           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, &x, 0, &y, 0, nullptr, 0);
     467           1 :         ASSERT_EQ(ls.getCoordinateDimension(), 2);
     468           1 :         ASSERT_EQ(ls.getX(0), 1);
     469           1 :         ASSERT_EQ(ls.getY(0), 2);
     470           1 :         ASSERT_EQ(ls.getZ(0), 0);
     471             :     }
     472             : 
     473             :     {
     474           1 :         OGRLineString ls;
     475           1 :         double x = 1, y = 2;
     476           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, &x, 0, &y, 0, nullptr, 0);
     477           1 :         ASSERT_EQ(ls.getCoordinateDimension(), 2);
     478           1 :         ASSERT_EQ(ls.getX(0), 1);
     479           1 :         ASSERT_EQ(ls.getY(0), 2);
     480           1 :         ASSERT_EQ(ls.getZ(0), 0);
     481             :     }
     482             : 
     483             :     {
     484           1 :         OGRLineString ls;
     485           1 :         double x = 1, y = 2;
     486           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, &x, 8, &y, 8, nullptr, 0);
     487           1 :         ASSERT_EQ(ls.getCoordinateDimension(), 2);
     488           1 :         ASSERT_EQ(ls.getX(0), 1);
     489           1 :         ASSERT_EQ(ls.getY(0), 2);
     490           1 :         ASSERT_EQ(ls.getZ(0), 0);
     491             :     }
     492             : 
     493             :     {
     494           1 :         OGRLineString ls;
     495           1 :         double x = 1, y = 2, z = 3;
     496           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, &x, 0, &y, 0, &z, 0);
     497           1 :         ASSERT_EQ(ls.getCoordinateDimension(), 3);
     498           1 :         ASSERT_EQ(ls.getX(0), 1);
     499           1 :         ASSERT_EQ(ls.getY(0), 2);
     500           1 :         ASSERT_EQ(ls.getZ(0), 3);
     501             :     }
     502             : 
     503             :     {
     504           1 :         OGRLineString ls;
     505           1 :         double x = 1, y = 2, z = 3;
     506           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, &x, 8, &y, 8, &z, 8);
     507           1 :         ASSERT_EQ(ls.getCoordinateDimension(), 3);
     508           1 :         ASSERT_EQ(ls.getX(0), 1);
     509           1 :         ASSERT_EQ(ls.getY(0), 2);
     510           1 :         ASSERT_EQ(ls.getZ(0), 3);
     511             :     }
     512             : 
     513             :     {
     514           2 :         OGRLineString ls;
     515           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
     516           1 :         OGR_G_SetPoints((OGRGeometryH)&ls, 1, nullptr, 0, nullptr, 0, nullptr,
     517             :                         0);
     518           1 :         CPLPopErrorHandler();
     519             :     }
     520             : }
     521             : 
     522           4 : TEST_F(test_ogr, OGR_G_CreateGeometry_unknown)
     523             : {
     524           1 :     EXPECT_EQ(OGR_G_CreateGeometry(wkbUnknown), nullptr);
     525           1 : }
     526             : 
     527           4 : TEST_F(test_ogr, style_manager)
     528             : {
     529           1 :     OGRStyleMgrH hSM = OGR_SM_Create(nullptr);
     530           1 :     EXPECT_TRUE(OGR_SM_InitStyleString(
     531             :         hSM, "PEN(w:2px,c:#000000,id:\"mapinfo-pen-2,ogr-pen-0\")"));
     532           1 :     OGRStyleToolH hTool = OGR_SM_GetPart(hSM, 0, nullptr);
     533           1 :     EXPECT_TRUE(hTool != nullptr);
     534           1 :     if (hTool)
     535             :     {
     536             :         int bValueIsNull;
     537             : 
     538           1 :         EXPECT_NEAR(OGR_ST_GetParamDbl(hTool, OGRSTPenWidth, &bValueIsNull),
     539             :                     2.0 * (1.0 / (72.0 * 39.37)) * 1000, 1e-6);
     540           1 :         EXPECT_EQ(OGR_ST_GetUnit(hTool), OGRSTUMM);
     541             : 
     542           1 :         OGR_ST_SetUnit(hTool, OGRSTUPixel, 1.0);
     543           1 :         EXPECT_EQ(OGR_ST_GetParamDbl(hTool, OGRSTPenWidth, &bValueIsNull), 2.0);
     544           1 :         EXPECT_EQ(OGR_ST_GetUnit(hTool), OGRSTUPixel);
     545           1 :         OGR_ST_Destroy(hTool);
     546             :     }
     547             : 
     548           1 :     OGR_SM_Destroy(hSM);
     549           1 : }
     550             : 
     551           4 : TEST_F(test_ogr, OGRParseDate)
     552             : {
     553             :     const auto OGRParseDateWrapper =
     554          64 :         [](const char *str, OGRField *psField, int nFlags)
     555             :     {
     556             :         // Putting inside a std::string helps Valgrind and other checkers to
     557             :         // detect out-of-bounds access
     558          64 :         return OGRParseDate(std::string(str).c_str(), psField, nFlags);
     559             :     };
     560             : 
     561             :     OGRField sField;
     562           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56", &sField, 0), TRUE);
     563           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     564           1 :     EXPECT_EQ(sField.Date.Month, 11);
     565           1 :     EXPECT_EQ(sField.Date.Day, 31);
     566           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     567           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     568           1 :     EXPECT_EQ(sField.Date.Second, 56.0f);
     569           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     570             : 
     571           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56+00", &sField, 0), TRUE);
     572           1 :     EXPECT_EQ(sField.Date.TZFlag, 100);
     573             : 
     574           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56+12:00", &sField, 0),
     575             :               TRUE);
     576           1 :     EXPECT_EQ(sField.Date.TZFlag, 100 + 12 * 4);
     577             : 
     578           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56+1200", &sField, 0),
     579             :               TRUE);
     580           1 :     EXPECT_EQ(sField.Date.TZFlag, 100 + 12 * 4);
     581             : 
     582           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56+815", &sField, 0), TRUE);
     583           1 :     EXPECT_EQ(sField.Date.TZFlag, 100 + 8 * 4 + 1);
     584             : 
     585           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56-12:00", &sField, 0),
     586             :               TRUE);
     587           1 :     EXPECT_EQ(sField.Date.TZFlag, 100 - 12 * 4);
     588             : 
     589           1 :     EXPECT_EQ(OGRParseDateWrapper(" 2017/11/31 12:34:56", &sField, 0), TRUE);
     590           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     591             : 
     592           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:56.789", &sField, 0), TRUE);
     593           1 :     EXPECT_EQ(sField.Date.Second, 56.789f);
     594             : 
     595             :     // Leap second
     596           1 :     EXPECT_EQ(OGRParseDateWrapper("2017/11/31 12:34:60", &sField, 0), TRUE);
     597           1 :     EXPECT_EQ(sField.Date.Second, 60.0f);
     598             : 
     599           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31T12:34:56", &sField, 0), TRUE);
     600           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     601           1 :     EXPECT_EQ(sField.Date.Month, 11);
     602           1 :     EXPECT_EQ(sField.Date.Day, 31);
     603           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     604           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     605           1 :     EXPECT_EQ(sField.Date.Second, 56.0f);
     606           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     607             : 
     608           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31T12:34:56Z", &sField, 0), TRUE);
     609           1 :     EXPECT_EQ(sField.Date.Second, 56.0f);
     610           1 :     EXPECT_EQ(sField.Date.TZFlag, 100);
     611             : 
     612           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31T12:34:56.789Z", &sField, 0),
     613             :               TRUE);
     614           1 :     EXPECT_EQ(sField.Date.Second, 56.789f);
     615           1 :     EXPECT_EQ(sField.Date.TZFlag, 100);
     616             : 
     617           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31T23:59:59.999999Z", &sField, 0),
     618             :               TRUE);
     619           1 :     EXPECT_EQ(sField.Date.Hour, 23);
     620           1 :     EXPECT_EQ(sField.Date.Minute, 59);
     621           1 :     EXPECT_EQ(sField.Date.Second, 59.999f);
     622             : 
     623           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31", &sField, 0), TRUE);
     624           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     625           1 :     EXPECT_EQ(sField.Date.Month, 11);
     626           1 :     EXPECT_EQ(sField.Date.Day, 31);
     627           1 :     EXPECT_EQ(sField.Date.Hour, 0);
     628           1 :     EXPECT_EQ(sField.Date.Minute, 0);
     629           1 :     EXPECT_EQ(sField.Date.Second, 0.0f);
     630           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     631             : 
     632           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-11-31Z", &sField, 0), TRUE);
     633           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     634           1 :     EXPECT_EQ(sField.Date.Month, 11);
     635           1 :     EXPECT_EQ(sField.Date.Day, 31);
     636           1 :     EXPECT_EQ(sField.Date.Hour, 0);
     637           1 :     EXPECT_EQ(sField.Date.Minute, 0);
     638           1 :     EXPECT_EQ(sField.Date.Second, 0.0f);
     639           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     640             : 
     641           1 :     EXPECT_EQ(OGRParseDateWrapper("12:34", &sField, 0), TRUE);
     642           1 :     EXPECT_EQ(sField.Date.Year, 0);
     643           1 :     EXPECT_EQ(sField.Date.Month, 0);
     644           1 :     EXPECT_EQ(sField.Date.Day, 0);
     645           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     646           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     647           1 :     EXPECT_EQ(sField.Date.Second, 0.0f);
     648           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     649             : 
     650           1 :     EXPECT_EQ(OGRParseDateWrapper("12:34:56", &sField, 0), TRUE);
     651           1 :     EXPECT_EQ(OGRParseDateWrapper("12:34:56.789", &sField, 0), TRUE);
     652             : 
     653           1 :     EXPECT_EQ(OGRParseDateWrapper("T12:34:56", &sField, 0), TRUE);
     654           1 :     EXPECT_EQ(sField.Date.Year, 0);
     655           1 :     EXPECT_EQ(sField.Date.Month, 0);
     656           1 :     EXPECT_EQ(sField.Date.Day, 0);
     657           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     658           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     659           1 :     EXPECT_EQ(sField.Date.Second, 56.0f);
     660           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     661             : 
     662           1 :     EXPECT_EQ(OGRParseDateWrapper("T123456", &sField, 0), TRUE);
     663           1 :     EXPECT_EQ(sField.Date.Year, 0);
     664           1 :     EXPECT_EQ(sField.Date.Month, 0);
     665           1 :     EXPECT_EQ(sField.Date.Day, 0);
     666           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     667           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     668           1 :     EXPECT_EQ(sField.Date.Second, 56.0f);
     669           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     670             : 
     671           1 :     EXPECT_EQ(OGRParseDateWrapper("T123456.789", &sField, 0), TRUE);
     672           1 :     EXPECT_EQ(sField.Date.Year, 0);
     673           1 :     EXPECT_EQ(sField.Date.Month, 0);
     674           1 :     EXPECT_EQ(sField.Date.Day, 0);
     675           1 :     EXPECT_EQ(sField.Date.Hour, 12);
     676           1 :     EXPECT_EQ(sField.Date.Minute, 34);
     677           1 :     EXPECT_EQ(sField.Date.Second, 56.789f);
     678           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     679             : 
     680           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
     681           1 :     EXPECT_TRUE(!OGRParseDateWrapper("123456-01-01", &sField, 0));
     682           1 :     CPLPopErrorHandler();
     683           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017", &sField, 0));
     684           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017x-01-01", &sField, 0));
     685           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-1-01", &sField, 0));
     686           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-1", &sField, 0));
     687           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01x", &sField, 0));
     688           1 :     EXPECT_TRUE(!OGRParseDateWrapper("12:", &sField, 0));
     689           1 :     EXPECT_TRUE(!OGRParseDateWrapper("12:3", &sField, 0));
     690           1 :     EXPECT_TRUE(!OGRParseDateWrapper("1:23", &sField, 0));
     691           1 :     EXPECT_TRUE(!OGRParseDateWrapper("12:34:5", &sField, 0));
     692           1 :     EXPECT_TRUE(!OGRParseDateWrapper("1a:34", &sField, 0));
     693           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-a-31T12:34:56", &sField, 0));
     694           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-00-31T12:34:56", &sField, 0));
     695           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-13-31T12:34:56", &sField, 0));
     696           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-00T12:34:56", &sField, 0));
     697           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-aT12:34:56", &sField, 0));
     698           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-32T12:34:56", &sField, 0));
     699           1 :     EXPECT_TRUE(!OGRParseDateWrapper("a:34:56", &sField, 0));
     700           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01Ta:34:56", &sField, 0));
     701           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T25:34:56", &sField, 0));
     702           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T00:a:00", &sField, 0));
     703           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T00: 34:56", &sField, 0));
     704           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T00:61:00", &sField, 0));
     705           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T00:00:61", &sField, 0));
     706           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-01-01T00:00:a", &sField, 0));
     707             : 
     708             :     // Test OGRPARSEDATE_OPTION_LAX
     709           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-1-9", &sField, OGRPARSEDATE_OPTION_LAX),
     710             :               TRUE);
     711           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     712           1 :     EXPECT_EQ(sField.Date.Month, 1);
     713           1 :     EXPECT_EQ(sField.Date.Day, 9);
     714             : 
     715           1 :     EXPECT_EQ(
     716             :         OGRParseDateWrapper("2017-1-31", &sField, OGRPARSEDATE_OPTION_LAX),
     717             :         TRUE);
     718           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     719           1 :     EXPECT_EQ(sField.Date.Month, 1);
     720           1 :     EXPECT_EQ(sField.Date.Day, 31);
     721             : 
     722           1 :     EXPECT_EQ(OGRParseDateWrapper("2017-1-31T1:2:3", &sField,
     723             :                                   OGRPARSEDATE_OPTION_LAX),
     724             :               TRUE);
     725           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     726           1 :     EXPECT_EQ(sField.Date.Month, 1);
     727           1 :     EXPECT_EQ(sField.Date.Day, 31);
     728           1 :     EXPECT_EQ(sField.Date.Hour, 1);
     729           1 :     EXPECT_EQ(sField.Date.Minute, 2);
     730           1 :     EXPECT_EQ(sField.Date.Second, 3.0f);
     731           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     732             : 
     733           1 :     EXPECT_EQ(
     734             :         OGRParseDateWrapper("2017-1-31T1:3", &sField, OGRPARSEDATE_OPTION_LAX),
     735             :         TRUE);
     736           1 :     EXPECT_EQ(sField.Date.Year, 2017);
     737           1 :     EXPECT_EQ(sField.Date.Month, 1);
     738           1 :     EXPECT_EQ(sField.Date.Day, 31);
     739           1 :     EXPECT_EQ(sField.Date.Hour, 1);
     740           1 :     EXPECT_EQ(sField.Date.Minute, 3);
     741           1 :     EXPECT_EQ(sField.Date.Second, 0.0f);
     742           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     743             : 
     744           1 :     EXPECT_EQ(OGRParseDateWrapper("1:3", &sField, OGRPARSEDATE_OPTION_LAX),
     745             :               TRUE);
     746           1 :     EXPECT_EQ(sField.Date.Year, 0);
     747           1 :     EXPECT_EQ(sField.Date.Month, 0);
     748           1 :     EXPECT_EQ(sField.Date.Day, 0);
     749           1 :     EXPECT_EQ(sField.Date.Hour, 1);
     750           1 :     EXPECT_EQ(sField.Date.Minute, 3);
     751           1 :     EXPECT_EQ(sField.Date.Second, 0.0f);
     752           1 :     EXPECT_EQ(sField.Date.TZFlag, 0);
     753             : 
     754           1 :     EXPECT_TRUE(
     755             :         !OGRParseDateWrapper("2017-a-01", &sField, OGRPARSEDATE_OPTION_LAX));
     756           1 :     EXPECT_TRUE(
     757             :         !OGRParseDateWrapper("2017-0-01", &sField, OGRPARSEDATE_OPTION_LAX));
     758           1 :     EXPECT_TRUE(
     759             :         !OGRParseDateWrapper("2017-1", &sField, OGRPARSEDATE_OPTION_LAX));
     760           1 :     EXPECT_TRUE(
     761             :         !OGRParseDateWrapper("2017-1-", &sField, OGRPARSEDATE_OPTION_LAX));
     762           1 :     EXPECT_TRUE(
     763             :         !OGRParseDateWrapper("2017-1-a", &sField, OGRPARSEDATE_OPTION_LAX));
     764           1 :     EXPECT_TRUE(
     765             :         !OGRParseDateWrapper("2017-1-0", &sField, OGRPARSEDATE_OPTION_LAX));
     766           1 :     EXPECT_TRUE(
     767             :         !OGRParseDateWrapper("2017-1-32", &sField, OGRPARSEDATE_OPTION_LAX));
     768           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-1-1Ta:00:00", &sField,
     769             :                                      OGRPARSEDATE_OPTION_LAX));
     770           1 :     EXPECT_TRUE(
     771             :         !OGRParseDateWrapper("2017-1-1T1", &sField, OGRPARSEDATE_OPTION_LAX));
     772           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-1-1T00:a:00", &sField,
     773             :                                      OGRPARSEDATE_OPTION_LAX));
     774           1 :     EXPECT_TRUE(
     775             :         !OGRParseDateWrapper("2017-1-1T1:", &sField, OGRPARSEDATE_OPTION_LAX));
     776           1 :     EXPECT_TRUE(!OGRParseDateWrapper("2017-1-1T00:00:a", &sField,
     777             :                                      OGRPARSEDATE_OPTION_LAX));
     778           1 :     EXPECT_TRUE(!OGRParseDateWrapper("1a:3", &sField, OGRPARSEDATE_OPTION_LAX));
     779           1 : }
     780             : 
     781             : // Test OGRPolygon::IsPointOnSurface()
     782           4 : TEST_F(test_ogr, IsPointOnSurface)
     783             : {
     784           1 :     OGRPolygon oPoly;
     785             : 
     786           1 :     OGRPoint oEmptyPoint;
     787           1 :     ASSERT_TRUE(!oPoly.IsPointOnSurface(&oEmptyPoint));
     788             : 
     789           1 :     OGRPoint oPoint;
     790           1 :     oPoint.setX(1);
     791           1 :     oPoint.setY(1);
     792           1 :     ASSERT_TRUE(!oPoly.IsPointOnSurface(&oPoint));
     793             : 
     794           1 :     const char *pszPoly =
     795             :         "POLYGON((0 0,0 10,10 10,10 0,0 0),(4 4,4 6,6 6,6 4,4 4))";
     796           1 :     oPoly.importFromWkt(&pszPoly);
     797             : 
     798           1 :     ASSERT_TRUE(!oPoly.IsPointOnSurface(&oEmptyPoint));
     799             : 
     800           1 :     ASSERT_EQ(oPoly.IsPointOnSurface(&oPoint), TRUE);
     801             : 
     802           1 :     oPoint.setX(5);
     803           1 :     oPoint.setY(5);
     804           1 :     ASSERT_TRUE(!oPoly.IsPointOnSurface(&oPoint));
     805             : }
     806             : 
     807             : // Test gpb.h
     808           4 : TEST_F(test_ogr, gpb_h)
     809             : {
     810           1 :     ASSERT_EQ(GetVarUIntSize(0), 1);
     811           1 :     ASSERT_EQ(GetVarUIntSize(127), 1);
     812           1 :     ASSERT_EQ(GetVarUIntSize(128), 2);
     813           1 :     ASSERT_EQ(GetVarUIntSize((1 << 14) - 1), 2);
     814           1 :     ASSERT_EQ(GetVarUIntSize(1 << 14), 3);
     815           1 :     ASSERT_EQ(GetVarUIntSize(GUINT64_MAX), 10);
     816             : 
     817           1 :     ASSERT_EQ(GetVarIntSize(0), 1);
     818           1 :     ASSERT_EQ(GetVarIntSize(127), 1);
     819           1 :     ASSERT_EQ(GetVarIntSize(128), 2);
     820           1 :     ASSERT_EQ(GetVarIntSize((1 << 14) - 1), 2);
     821           1 :     ASSERT_EQ(GetVarIntSize(1 << 14), 3);
     822           1 :     ASSERT_EQ(GetVarIntSize(GINT64_MAX), 9);
     823           1 :     ASSERT_EQ(GetVarIntSize(-1), 10);
     824           1 :     ASSERT_EQ(GetVarIntSize(GINT64_MIN), 10);
     825             : 
     826           1 :     ASSERT_EQ(GetVarSIntSize(0), 1);
     827           1 :     ASSERT_EQ(GetVarSIntSize(63), 1);
     828           1 :     ASSERT_EQ(GetVarSIntSize(64), 2);
     829           1 :     ASSERT_EQ(GetVarSIntSize(-1), 1);
     830           1 :     ASSERT_EQ(GetVarSIntSize(-64), 1);
     831           1 :     ASSERT_EQ(GetVarSIntSize(-65), 2);
     832           1 :     ASSERT_EQ(GetVarSIntSize(GINT64_MIN), 10);
     833           1 :     ASSERT_EQ(GetVarSIntSize(GINT64_MAX), 10);
     834             : 
     835           1 :     ASSERT_EQ(GetTextSize(""), 1);
     836           1 :     ASSERT_EQ(GetTextSize(" "), 2);
     837           1 :     ASSERT_EQ(GetTextSize(std::string(" ")), 2);
     838             : 
     839           1 :     GByte abyBuffer[11] = {0};
     840             :     GByte *pabyBuffer;
     841             :     const GByte *pabyBufferRO;
     842             : 
     843           1 :     pabyBuffer = abyBuffer;
     844           1 :     WriteVarUInt(&pabyBuffer, 0);
     845           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 1);
     846           1 :     pabyBufferRO = abyBuffer;
     847           1 :     ASSERT_EQ(ReadVarUInt64(&pabyBufferRO), 0U);
     848             : 
     849           1 :     pabyBuffer = abyBuffer;
     850           1 :     WriteVarUInt(&pabyBuffer, 127);
     851           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 1);
     852           1 :     pabyBufferRO = abyBuffer;
     853           1 :     ASSERT_EQ(ReadVarUInt64(&pabyBufferRO), 127U);
     854             : 
     855           1 :     pabyBuffer = abyBuffer;
     856           1 :     WriteVarUInt(&pabyBuffer, 0xDEADBEEFU);
     857           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 5);
     858           1 :     pabyBufferRO = abyBuffer;
     859           1 :     ASSERT_EQ(ReadVarUInt64(&pabyBufferRO), 0xDEADBEEFU);
     860             : 
     861           1 :     pabyBuffer = abyBuffer;
     862           1 :     WriteVarUInt(&pabyBuffer, GUINT64_MAX);
     863           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 10);
     864           1 :     pabyBufferRO = abyBuffer;
     865           1 :     ASSERT_EQ(ReadVarUInt64(&pabyBufferRO), GUINT64_MAX);
     866             : 
     867           1 :     pabyBuffer = abyBuffer;
     868           1 :     WriteVarInt(&pabyBuffer, GINT64_MAX);
     869           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 9);
     870           1 :     pabyBufferRO = abyBuffer;
     871           1 :     ASSERT_EQ(ReadVarInt64(&pabyBufferRO), GINT64_MAX);
     872             : 
     873           1 :     pabyBuffer = abyBuffer;
     874           1 :     WriteVarInt(&pabyBuffer, -1);
     875           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 10);
     876           1 :     pabyBufferRO = abyBuffer;
     877           1 :     ASSERT_EQ(ReadVarInt64(&pabyBufferRO), -1);
     878             : 
     879           1 :     pabyBuffer = abyBuffer;
     880           1 :     WriteVarInt(&pabyBuffer, GINT64_MIN);
     881           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 10);
     882           1 :     pabyBufferRO = abyBuffer;
     883           1 :     ASSERT_EQ(ReadVarInt64(&pabyBufferRO), GINT64_MIN);
     884             : 
     885           1 :     pabyBuffer = abyBuffer;
     886           1 :     WriteVarSInt(&pabyBuffer, 0);
     887           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 1);
     888             :     {
     889             :         GIntBig nVal;
     890           1 :         pabyBufferRO = abyBuffer;
     891           1 :         READ_VARSINT64(pabyBufferRO, abyBuffer + 10, nVal);
     892           1 :         ASSERT_EQ(nVal, 0);
     893             :     }
     894             : 
     895           1 :     pabyBuffer = abyBuffer;
     896           1 :     WriteVarSInt(&pabyBuffer, 1);
     897           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 1);
     898             :     {
     899             :         GIntBig nVal;
     900           1 :         pabyBufferRO = abyBuffer;
     901           1 :         READ_VARSINT64(pabyBufferRO, abyBuffer + 10, nVal);
     902           1 :         ASSERT_EQ(nVal, 1);
     903             :     }
     904             : 
     905           1 :     pabyBuffer = abyBuffer;
     906           1 :     WriteVarSInt(&pabyBuffer, -1);
     907           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 1);
     908             :     {
     909             :         GIntBig nVal;
     910           1 :         pabyBufferRO = abyBuffer;
     911           1 :         READ_VARSINT64(pabyBufferRO, abyBuffer + 10, nVal);
     912           1 :         ASSERT_EQ(nVal, -1);
     913             :     }
     914             : 
     915           1 :     pabyBuffer = abyBuffer;
     916           1 :     WriteVarSInt(&pabyBuffer, GINT64_MAX);
     917           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 10);
     918             :     {
     919             :         GIntBig nVal;
     920           1 :         pabyBufferRO = abyBuffer;
     921           1 :         READ_VARSINT64(pabyBufferRO, abyBuffer + 10, nVal);
     922           1 :         ASSERT_EQ(nVal, GINT64_MAX);
     923             :     }
     924             : 
     925           1 :     pabyBuffer = abyBuffer;
     926           1 :     WriteVarSInt(&pabyBuffer, GINT64_MIN);
     927           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 10);
     928             :     {
     929             :         GIntBig nVal;
     930           1 :         pabyBufferRO = abyBuffer;
     931           1 :         READ_VARSINT64(pabyBufferRO, abyBuffer + 10, nVal);
     932           1 :         ASSERT_EQ(nVal, GINT64_MIN);
     933             :     }
     934             : 
     935           1 :     pabyBuffer = abyBuffer;
     936           1 :     WriteText(&pabyBuffer, "x");
     937           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 2);
     938           1 :     ASSERT_EQ(abyBuffer[0], 1);
     939           1 :     ASSERT_EQ(abyBuffer[1], 'x');
     940             : 
     941           1 :     pabyBuffer = abyBuffer;
     942           1 :     WriteText(&pabyBuffer, std::string("x"));
     943           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 2);
     944           1 :     ASSERT_EQ(abyBuffer[0], 1);
     945           1 :     ASSERT_EQ(abyBuffer[1], 'x');
     946             : 
     947           1 :     pabyBuffer = abyBuffer;
     948           1 :     WriteFloat32(&pabyBuffer, 1.25f);
     949           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 4);
     950           1 :     pabyBufferRO = abyBuffer;
     951           1 :     ASSERT_EQ(ReadFloat32(&pabyBufferRO, abyBuffer + 4), 1.25f);
     952             : 
     953           1 :     pabyBuffer = abyBuffer;
     954           1 :     WriteFloat64(&pabyBuffer, 1.25);
     955           1 :     ASSERT_EQ(pabyBuffer - abyBuffer, 8);
     956           1 :     pabyBufferRO = abyBuffer;
     957           1 :     ASSERT_EQ(ReadFloat64(&pabyBufferRO, abyBuffer + 8), 1.25);
     958             : }
     959             : 
     960             : // Test OGRGeometry::toXXXXX()
     961           4 : TEST_F(test_ogr, OGRGeometry_toXXXXX)
     962             : {
     963             : #define CONCAT(X, Y) X##Y
     964             : #define TEST_OGRGEOMETRY_TO(X)                                                 \
     965             :     {                                                                          \
     966             :         CONCAT(OGR, X) o;                                                      \
     967             :         OGRGeometry *poGeom = &o;                                              \
     968             :         ASSERT_EQ(poGeom->CONCAT(to, X)(), &o);                                \
     969             :     }
     970             : 
     971           1 :     TEST_OGRGEOMETRY_TO(Point);
     972           1 :     TEST_OGRGEOMETRY_TO(LineString);
     973           1 :     TEST_OGRGEOMETRY_TO(LinearRing);
     974           1 :     TEST_OGRGEOMETRY_TO(CircularString);
     975           1 :     TEST_OGRGEOMETRY_TO(CompoundCurve);
     976           1 :     TEST_OGRGEOMETRY_TO(CurvePolygon);
     977           1 :     TEST_OGRGEOMETRY_TO(Polygon);
     978           1 :     TEST_OGRGEOMETRY_TO(GeometryCollection);
     979           1 :     TEST_OGRGEOMETRY_TO(MultiSurface);
     980           1 :     TEST_OGRGEOMETRY_TO(MultiPolygon);
     981           1 :     TEST_OGRGEOMETRY_TO(MultiPoint);
     982           1 :     TEST_OGRGEOMETRY_TO(MultiCurve);
     983           1 :     TEST_OGRGEOMETRY_TO(MultiLineString);
     984           1 :     TEST_OGRGEOMETRY_TO(Triangle);
     985           1 :     TEST_OGRGEOMETRY_TO(PolyhedralSurface);
     986           1 :     TEST_OGRGEOMETRY_TO(TriangulatedSurface);
     987             :     {
     988           1 :         OGRLineString o;
     989           1 :         OGRGeometry *poGeom = &o;
     990           1 :         ASSERT_EQ(poGeom->toCurve(), &o);
     991             :     }
     992             :     {
     993           1 :         OGRPolygon o;
     994           1 :         OGRGeometry *poGeom = &o;
     995           1 :         ASSERT_EQ(poGeom->toSurface(), &o);
     996             :     }
     997             : 
     998             :     {
     999           1 :         OGRPoint o;
    1000             :         // ASSERT_EQ(o.toPoint(), &o);
    1001             :     }
    1002             : 
    1003             :     {
    1004           1 :         OGRLineString o;
    1005           1 :         ASSERT_EQ(o.toCurve(), &o);
    1006           1 :         ASSERT_EQ(o.toSimpleCurve(), &o);
    1007             :         // ASSERT_EQ(o.toLineString(), &o);
    1008             : 
    1009             :         {
    1010           1 :             OGRCurve &oRef = o;
    1011           1 :             ASSERT_EQ(oRef.toLineString(), &o);
    1012             :         }
    1013             : 
    1014             :         {
    1015           1 :             OGRSimpleCurve &oRef = o;
    1016           1 :             ASSERT_EQ(oRef.toLineString(), &o);
    1017             :         }
    1018             :     }
    1019             : 
    1020             :     {
    1021           1 :         OGRLinearRing o;
    1022           1 :         ASSERT_EQ(o.toCurve(), &o);
    1023           1 :         ASSERT_EQ(o.toSimpleCurve(), &o);
    1024             :         // ASSERT_EQ(o.toLinearRing(), &o);
    1025             : 
    1026             :         {
    1027           1 :             OGRCurve &oRef = o;
    1028           1 :             ASSERT_EQ(oRef.toLinearRing(), &o);
    1029             :         }
    1030             :         {
    1031           1 :             OGRSimpleCurve &oRef = o;
    1032           1 :             ASSERT_EQ(oRef.toLinearRing(), &o);
    1033             :         }
    1034             :         {
    1035           1 :             OGRLineString &oRef = o;
    1036           1 :             ASSERT_EQ(oRef.toLinearRing(), &o);
    1037             :         }
    1038             :     }
    1039             : 
    1040             :     {
    1041           1 :         OGRCircularString o;
    1042           1 :         ASSERT_EQ(o.toCurve(), &o);
    1043           1 :         ASSERT_EQ(o.toSimpleCurve(), &o);
    1044             :         // ASSERT_EQ(o.toCircularString(), &o);
    1045             : 
    1046             :         {
    1047           1 :             OGRCurve &oRef = o;
    1048           1 :             ASSERT_EQ(oRef.toCircularString(), &o);
    1049             :         }
    1050             : 
    1051             :         {
    1052           1 :             OGRSimpleCurve &oRef = o;
    1053           1 :             ASSERT_EQ(oRef.toCircularString(), &o);
    1054             :         }
    1055             :     }
    1056             : 
    1057             :     {
    1058           1 :         OGRCompoundCurve o;
    1059           1 :         ASSERT_EQ(o.toCurve(), &o);
    1060             :         // ASSERT_EQ(o.toCompoundCurve(), &o);
    1061             : 
    1062             :         {
    1063           1 :             OGRCurve &oRef = o;
    1064           1 :             ASSERT_EQ(oRef.toCompoundCurve(), &o);
    1065             :         }
    1066             :     }
    1067             : 
    1068             :     {
    1069           1 :         OGRCurvePolygon o;
    1070           1 :         ASSERT_EQ(o.toSurface(), &o);
    1071             :         // ASSERT_EQ(o.toCurvePolygon(), &o);
    1072             : 
    1073             :         {
    1074           1 :             OGRSurface &oRef = o;
    1075           1 :             ASSERT_EQ(oRef.toCurvePolygon(), &o);
    1076             :         }
    1077             :     }
    1078             : 
    1079             :     {
    1080           1 :         OGRPolygon o;
    1081           1 :         ASSERT_EQ(o.toSurface(), &o);
    1082           1 :         ASSERT_EQ(o.toCurvePolygon(), &o);
    1083             :         // ASSERT_EQ(o.toPolygon(), &o);
    1084             : 
    1085             :         {
    1086           1 :             OGRSurface &oRef = o;
    1087           1 :             ASSERT_EQ(oRef.toPolygon(), &o);
    1088             :         }
    1089             : 
    1090             :         {
    1091           1 :             OGRCurvePolygon &oRef = o;
    1092           1 :             ASSERT_EQ(oRef.toPolygon(), &o);
    1093             :         }
    1094             :     }
    1095             : 
    1096             :     {
    1097           1 :         OGRTriangle o;
    1098           1 :         ASSERT_EQ(o.toSurface(), &o);
    1099           1 :         ASSERT_EQ(o.toCurvePolygon(), &o);
    1100           1 :         ASSERT_EQ(o.toPolygon(), &o);
    1101             :         // ASSERT_EQ(o.toTriangle(), &o);
    1102             : 
    1103             :         {
    1104           1 :             OGRSurface &oRef = o;
    1105           1 :             ASSERT_EQ(oRef.toTriangle(), &o);
    1106             :         }
    1107             : 
    1108             :         {
    1109           1 :             OGRCurvePolygon &oRef = o;
    1110           1 :             ASSERT_EQ(oRef.toTriangle(), &o);
    1111             :         }
    1112             : 
    1113             :         {
    1114           1 :             OGRPolygon &oRef = o;
    1115           1 :             ASSERT_EQ(oRef.toTriangle(), &o);
    1116             :         }
    1117             :     }
    1118             : 
    1119             :     {
    1120           1 :         OGRMultiPoint o;
    1121           1 :         ASSERT_EQ(o.toGeometryCollection(), &o);
    1122             :         // ASSERT_EQ(o.toMultiPoint(), &o);
    1123             : 
    1124             :         {
    1125           1 :             OGRGeometryCollection &oRef = o;
    1126           1 :             ASSERT_EQ(oRef.toMultiPoint(), &o);
    1127             :         }
    1128             :     }
    1129             : 
    1130             :     {
    1131           1 :         OGRMultiCurve o;
    1132           1 :         ASSERT_EQ(o.toGeometryCollection(), &o);
    1133             :         // ASSERT_EQ(o.toMultiCurve(), &o);
    1134             : 
    1135             :         {
    1136           1 :             OGRGeometryCollection &oRef = o;
    1137           1 :             ASSERT_EQ(oRef.toMultiCurve(), &o);
    1138             :         }
    1139             :     }
    1140             : 
    1141             :     {
    1142           1 :         OGRMultiLineString o;
    1143           1 :         ASSERT_EQ(o.toGeometryCollection(), &o);
    1144           1 :         ASSERT_EQ(o.toMultiCurve(), &o);
    1145             :         // ASSERT_EQ(o.toMultiLineString(), &o);
    1146             : 
    1147             :         {
    1148           1 :             OGRMultiCurve &oRef = o;
    1149           1 :             ASSERT_EQ(oRef.toMultiLineString(), &o);
    1150             :         }
    1151             : 
    1152             :         {
    1153           1 :             OGRGeometryCollection &oRef = o;
    1154           1 :             ASSERT_EQ(oRef.toMultiLineString(), &o);
    1155             :         }
    1156             :     }
    1157             : 
    1158             :     {
    1159           1 :         OGRMultiSurface o;
    1160           1 :         ASSERT_EQ(o.toGeometryCollection(), &o);
    1161             :         // ASSERT_EQ(o.toMultiSurface(), &o);
    1162             : 
    1163             :         {
    1164           1 :             OGRGeometryCollection &oRef = o;
    1165           1 :             ASSERT_EQ(oRef.toMultiSurface(), &o);
    1166             :         }
    1167             :     }
    1168             : 
    1169             :     {
    1170           1 :         OGRMultiPolygon o;
    1171           1 :         ASSERT_EQ(o.toGeometryCollection(), &o);
    1172           1 :         ASSERT_EQ(o.toMultiSurface(), &o);
    1173             :         // ASSERT_EQ(o.toMultiPolygon(), &o);
    1174             : 
    1175             :         {
    1176           1 :             OGRMultiSurface &oRef = o;
    1177           1 :             ASSERT_EQ(oRef.toMultiPolygon(), &o);
    1178             :         }
    1179             : 
    1180             :         {
    1181           1 :             OGRGeometryCollection &oRef = o;
    1182           1 :             ASSERT_EQ(oRef.toMultiPolygon(), &o);
    1183             :         }
    1184             :     }
    1185             : 
    1186             :     {
    1187           1 :         OGRPolyhedralSurface o;
    1188           1 :         ASSERT_EQ(o.toSurface(), &o);
    1189             :         // ASSERT_EQ(o.toPolyhedralSurface(), &o);
    1190             : 
    1191             :         {
    1192           1 :             OGRSurface &oRef = o;
    1193           1 :             ASSERT_EQ(oRef.toPolyhedralSurface(), &o);
    1194             :         }
    1195             :     }
    1196             : 
    1197             :     {
    1198           1 :         OGRTriangulatedSurface o;
    1199           1 :         ASSERT_EQ(o.toSurface(), &o);
    1200           1 :         ASSERT_EQ(o.toPolyhedralSurface(), &o);
    1201             :         // ASSERT_EQ(o.toTriangulatedSurface(), &o);
    1202             : 
    1203             :         {
    1204           1 :             OGRSurface &oRef = o;
    1205           1 :             ASSERT_EQ(oRef.toTriangulatedSurface(), &o);
    1206             :         }
    1207             : 
    1208             :         {
    1209           1 :             OGRPolyhedralSurface &oRef = o;
    1210           1 :             ASSERT_EQ(oRef.toTriangulatedSurface(), &o);
    1211             :         }
    1212             :     }
    1213             : }
    1214             : 
    1215          34 : template <typename T> void TestIterator(T *obj, int nExpectedPointCount)
    1216             : {
    1217          34 :     int nCount = 0;
    1218          71 :     for (auto &elt : obj)
    1219             :     {
    1220          25 :         nCount++;
    1221          25 :         CPL_IGNORE_RET_VAL(elt);
    1222             :     }
    1223          34 :     ASSERT_EQ(nCount, nExpectedPointCount);
    1224             : 
    1225          34 :     nCount = 0;
    1226          34 :     const T *const_obj(obj);
    1227          71 :     for (const auto &elt : const_obj)
    1228             :     {
    1229          25 :         nCount++;
    1230          25 :         CPL_IGNORE_RET_VAL(elt);
    1231             :     }
    1232          34 :     ASSERT_EQ(nCount, nExpectedPointCount);
    1233             : }
    1234             : 
    1235             : template <typename Concrete, typename Abstract = Concrete>
    1236          34 : void TestIterator(const char *pszWKT = nullptr, int nExpectedPointCount = 0)
    1237             : {
    1238          68 :     Concrete obj;
    1239          34 :     if (pszWKT)
    1240             :     {
    1241          18 :         obj.importFromWkt(&pszWKT);
    1242             :     }
    1243          34 :     TestIterator<Abstract>(&obj, nExpectedPointCount);
    1244          34 : }
    1245             : 
    1246             : // Test geometry visitor
    1247           4 : TEST_F(test_ogr, OGRGeometry_visitor)
    1248             : {
    1249             :     static const struct
    1250             :     {
    1251             :         const char *pszWKT;
    1252             :         int nExpectedPointCount;
    1253             :     } asTests[] = {
    1254             :         {"POINT(0 0)", 1},
    1255             :         {"LINESTRING(0 0)", 1},
    1256             :         {"POLYGON((0 0),(0 0))", 2},
    1257             :         {"MULTIPOINT(0 0)", 1},
    1258             :         {"MULTILINESTRING((0 0))", 1},
    1259             :         {"MULTIPOLYGON(((0 0)))", 1},
    1260             :         {"GEOMETRYCOLLECTION(POINT(0 0))", 1},
    1261             :         {"CIRCULARSTRING(0 0,1 1,0 0)", 3},
    1262             :         {"COMPOUNDCURVE((0 0,1 1))", 2},
    1263             :         {"CURVEPOLYGON((0 0,1 1,1 0,0 0))", 4},
    1264             :         {"MULTICURVE((0 0))", 1},
    1265             :         {"MULTISURFACE(((0 0)))", 1},
    1266             :         {"TRIANGLE((0 0,0 1,1 1,0 0))", 4},
    1267             :         {"POLYHEDRALSURFACE(((0 0,0 1,1 1,0 0)))", 4},
    1268             :         {"TIN(((0 0,0 1,1 1,0 0)))", 4},
    1269             :     };
    1270             : 
    1271             :     class PointCounterVisitor : public OGRDefaultGeometryVisitor
    1272             :     {
    1273             :         int m_nPoints = 0;
    1274             : 
    1275             :       public:
    1276          15 :         PointCounterVisitor()
    1277          15 :         {
    1278          15 :         }
    1279             : 
    1280             :         using OGRDefaultGeometryVisitor::visit;
    1281             : 
    1282          31 :         void visit(OGRPoint *) override
    1283             :         {
    1284          31 :             m_nPoints++;
    1285          31 :         }
    1286             : 
    1287          15 :         int getNumPoints() const
    1288             :         {
    1289          15 :             return m_nPoints;
    1290             :         }
    1291             :     };
    1292             : 
    1293             :     class PointCounterConstVisitor : public OGRDefaultConstGeometryVisitor
    1294             :     {
    1295             :         int m_nPoints = 0;
    1296             : 
    1297             :       public:
    1298          15 :         PointCounterConstVisitor()
    1299          15 :         {
    1300          15 :         }
    1301             : 
    1302             :         using OGRDefaultConstGeometryVisitor::visit;
    1303             : 
    1304          31 :         void visit(const OGRPoint *) override
    1305             :         {
    1306          31 :             m_nPoints++;
    1307          31 :         }
    1308             : 
    1309          15 :         int getNumPoints() const
    1310             :         {
    1311          15 :             return m_nPoints;
    1312             :         }
    1313             :     };
    1314             : 
    1315          16 :     for (size_t i = 0; i < CPL_ARRAYSIZE(asTests); i++)
    1316             :     {
    1317          15 :         OGRGeometry *poGeom = nullptr;
    1318          15 :         OGRGeometryFactory::createFromWkt(asTests[i].pszWKT, nullptr, &poGeom);
    1319          15 :         PointCounterVisitor oVisitor;
    1320          15 :         poGeom->accept(&oVisitor);
    1321          15 :         ASSERT_EQ(oVisitor.getNumPoints(), asTests[i].nExpectedPointCount);
    1322          15 :         PointCounterConstVisitor oConstVisitor;
    1323          15 :         poGeom->accept(&oConstVisitor);
    1324          15 :         ASSERT_EQ(oConstVisitor.getNumPoints(), asTests[i].nExpectedPointCount);
    1325          15 :         delete poGeom;
    1326             :     }
    1327             : 
    1328             :     {
    1329           2 :         OGRLineString ls;
    1330           1 :         ls.setNumPoints(2);
    1331           2 :         auto oIter1 = ls.begin();
    1332           1 :         EXPECT_TRUE(oIter1 != ls.end());
    1333           1 :         EXPECT_TRUE(!(oIter1 != ls.begin()));
    1334           2 :         auto oIter2 = ls.begin();
    1335           1 :         EXPECT_TRUE(!(oIter1 != oIter2));
    1336           1 :         ++oIter2;
    1337           1 :         EXPECT_TRUE(oIter1 != oIter2);
    1338           1 :         ++oIter2;
    1339           1 :         EXPECT_TRUE(oIter1 != oIter2);
    1340             :     }
    1341             : 
    1342             :     {
    1343           2 :         OGRLineString ls;
    1344           1 :         EXPECT_TRUE(!(ls.begin() != ls.end()));
    1345             :     }
    1346             : 
    1347           1 :     TestIterator<OGRLineString>();
    1348           1 :     TestIterator<OGRLineString>("LINESTRING(0 0)", 1);
    1349           1 :     TestIterator<OGRLineString, OGRCurve>("LINESTRING(0 0)", 1);
    1350           1 :     TestIterator<OGRLineString, OGRCurve>();
    1351           1 :     TestIterator<OGRLinearRing>();
    1352           1 :     TestIterator<OGRCircularString>();
    1353           1 :     TestIterator<OGRCircularString>("CIRCULARSTRING(0 0,1 1,0 0)", 3);
    1354           1 :     TestIterator<OGRCircularString, OGRCurve>("CIRCULARSTRING(0 0,1 1,0 0)", 3);
    1355           1 :     TestIterator<OGRCompoundCurve>();
    1356           1 :     TestIterator<OGRCompoundCurve>("COMPOUNDCURVE((0 0,1 1))", 1);
    1357           1 :     TestIterator<OGRCompoundCurve, OGRCurve>(
    1358             :         "COMPOUNDCURVE((0 0,1 1),CIRCULARSTRING(1 1,2 2,3 3))", 4);
    1359           1 :     TestIterator<OGRCompoundCurve>("COMPOUNDCURVE(CIRCULARSTRING EMPTY)", 1);
    1360           1 :     TestIterator<OGRCurvePolygon>();
    1361           1 :     TestIterator<OGRCurvePolygon>("CURVEPOLYGON((0 0,1 1,1 0,0 0))", 1);
    1362           1 :     TestIterator<OGRPolygon>();
    1363           1 :     TestIterator<OGRPolygon>("POLYGON((0 0,1 1,1 0,0 0))", 1);
    1364           1 :     TestIterator<OGRGeometryCollection>();
    1365           1 :     TestIterator<OGRGeometryCollection>("GEOMETRYCOLLECTION(POINT(0 0))", 1);
    1366           1 :     TestIterator<OGRMultiSurface>();
    1367           1 :     TestIterator<OGRMultiSurface>("MULTISURFACE(((0 0)))", 1);
    1368           1 :     TestIterator<OGRMultiPolygon>();
    1369           1 :     TestIterator<OGRMultiPolygon>("MULTIPOLYGON(((0 0)))", 1);
    1370           1 :     TestIterator<OGRMultiPoint>();
    1371           1 :     TestIterator<OGRMultiPoint>("MULTIPOINT(0 0)", 1);
    1372           1 :     TestIterator<OGRMultiCurve>();
    1373           1 :     TestIterator<OGRMultiCurve>("MULTICURVE((0 0))", 1);
    1374           1 :     TestIterator<OGRMultiLineString>();
    1375           1 :     TestIterator<OGRMultiLineString>("MULTILINESTRING((0 0))", 1);
    1376           1 :     TestIterator<OGRTriangle>();
    1377           1 :     TestIterator<OGRTriangle>("TRIANGLE((0 0,0 1,1 1,0 0))", 1);
    1378           1 :     TestIterator<OGRPolyhedralSurface>();
    1379           1 :     TestIterator<OGRPolyhedralSurface>("POLYHEDRALSURFACE(((0 0,0 1,1 1,0 0)))",
    1380             :                                        1);
    1381           1 :     TestIterator<OGRTriangulatedSurface>();
    1382           1 :     TestIterator<OGRTriangulatedSurface>("TIN(((0 0,0 1,1 1,0 0)))", 1);
    1383             : 
    1384             :     // Test that the update of the iterated point of a linestring is
    1385             :     // immediately taken into account
    1386             :     // (https://github.com/OSGeo/gdal/issues/6215)
    1387             :     {
    1388           1 :         OGRLineString oLS;
    1389           1 :         oLS.addPoint(1, 2);
    1390           1 :         oLS.addPoint(3, 4);
    1391           1 :         int i = 0;
    1392           3 :         for (auto &&p : oLS)
    1393             :         {
    1394           2 :             p.setX(i * 10);
    1395           2 :             p.setY(i * 10 + 1);
    1396           2 :             p.setZ(i * 10 + 2);
    1397           2 :             p.setM(i * 10 + 3);
    1398           2 :             ASSERT_EQ(oLS.getX(i), p.getX());
    1399           2 :             ASSERT_EQ(oLS.getY(i), p.getY());
    1400           2 :             ASSERT_EQ(oLS.getZ(i), p.getZ());
    1401           2 :             ASSERT_EQ(oLS.getM(i), p.getM());
    1402           2 :             ++i;
    1403             :         }
    1404             :     }
    1405             : 
    1406             :     {
    1407             :         class PointCounterVisitorAndUpdate : public OGRDefaultGeometryVisitor
    1408             :         {
    1409             :           public:
    1410             :             PointCounterVisitorAndUpdate() = default;
    1411             : 
    1412             :             using OGRDefaultGeometryVisitor::visit;
    1413             : 
    1414           2 :             void visit(OGRPoint *poPoint) override
    1415             :             {
    1416           2 :                 poPoint->setZ(100);
    1417           2 :                 poPoint->setM(1000);
    1418           2 :             }
    1419             :         };
    1420             : 
    1421           1 :         OGRLineString oLS;
    1422           1 :         oLS.addPoint(1, 2);
    1423           1 :         oLS.addPoint(3, 4);
    1424           0 :         PointCounterVisitorAndUpdate oVisitor;
    1425           1 :         oLS.accept(&oVisitor);
    1426             : 
    1427           1 :         ASSERT_EQ(oLS.getZ(0), 100.0);
    1428           1 :         ASSERT_EQ(oLS.getZ(1), 100.0);
    1429           1 :         ASSERT_EQ(oLS.getM(0), 1000.0);
    1430           1 :         ASSERT_EQ(oLS.getM(1), 1000.0);
    1431             :     }
    1432             : }
    1433             : 
    1434             : // Test OGRToOGCGeomType()
    1435           4 : TEST_F(test_ogr, OGRToOGCGeomType)
    1436             : {
    1437           1 :     EXPECT_STREQ(OGRToOGCGeomType(wkbPoint), "POINT");
    1438           1 :     EXPECT_STREQ(OGRToOGCGeomType(wkbPointM), "POINT");
    1439           1 :     EXPECT_STREQ(OGRToOGCGeomType(wkbPoint, /*bCamelCase=*/true), "Point");
    1440           1 :     EXPECT_STREQ(
    1441             :         OGRToOGCGeomType(wkbPoint, /*bCamelCase=*/true, /*bAddZM=*/true),
    1442             :         "Point");
    1443           1 :     EXPECT_STREQ(
    1444             :         OGRToOGCGeomType(wkbPoint25D, /*bCamelCase=*/true, /*bAddZM=*/true),
    1445             :         "PointZ");
    1446           1 :     EXPECT_STREQ(
    1447             :         OGRToOGCGeomType(wkbPointM, /*bCamelCase=*/true, /*bAddZM=*/true),
    1448             :         "PointM");
    1449           1 :     EXPECT_STREQ(
    1450             :         OGRToOGCGeomType(wkbPointZM, /*bCamelCase=*/true, /*bAddZM=*/true),
    1451             :         "PointZM");
    1452           1 :     EXPECT_STREQ(OGRToOGCGeomType(wkbPointZM, /*bCamelCase=*/true,
    1453             :                                   /*bAddZM=*/true, /*bAddSpaceBeforeZM=*/true),
    1454             :                  "Point ZM");
    1455           1 : }
    1456             : 
    1457             : // Test layer, dataset-feature and layer-feature iterators
    1458           4 : TEST_F(test_ogr, DatasetFeature_and_LayerFeature_iterators)
    1459             : {
    1460           1 :     if (!GDALGetDriverByName("ESRI Shapefile"))
    1461             :     {
    1462           0 :         GTEST_SKIP() << "ESRI Shapefile driver missing";
    1463             :     }
    1464             :     else
    1465             :     {
    1466           1 :         std::string file(data_ + SEP + "poly.shp");
    1467             :         GDALDatasetUniquePtr poDS(
    1468           1 :             GDALDataset::Open(file.c_str(), GDAL_OF_VECTOR));
    1469           1 :         ASSERT_TRUE(poDS != nullptr);
    1470             : 
    1471             :         {
    1472           1 :             GIntBig nExpectedFID = 0;
    1473          11 :             for (const auto &oFeatureLayerPair : poDS->GetFeatures())
    1474             :             {
    1475          10 :                 ASSERT_EQ(oFeatureLayerPair.feature->GetFID(), nExpectedFID);
    1476          10 :                 nExpectedFID++;
    1477          10 :                 ASSERT_EQ(oFeatureLayerPair.layer, poDS->GetLayer(0));
    1478             :             }
    1479           1 :             ASSERT_EQ(nExpectedFID, 10);
    1480             :         }
    1481             : 
    1482           1 :         ASSERT_EQ(poDS->GetLayers().size(), 1U);
    1483           1 :         ASSERT_EQ(poDS->GetLayers()[0], poDS->GetLayer(0));
    1484           1 :         ASSERT_EQ(poDS->GetLayers()[static_cast<size_t>(0)], poDS->GetLayer(0));
    1485           1 :         ASSERT_EQ(poDS->GetLayers()["poly"], poDS->GetLayer(0));
    1486             : 
    1487           2 :         for (auto poLayer : poDS->GetLayers())
    1488             :         {
    1489           1 :             GIntBig nExpectedFID = 0;
    1490          11 :             for (const auto &poFeature : poLayer)
    1491             :             {
    1492          10 :                 ASSERT_EQ(poFeature->GetFID(), nExpectedFID);
    1493          10 :                 nExpectedFID++;
    1494             :             }
    1495           1 :             ASSERT_EQ(nExpectedFID, 10);
    1496             : 
    1497           1 :             nExpectedFID = 0;
    1498          11 :             for (const auto &oFeatureLayerPair : poDS->GetFeatures())
    1499             :             {
    1500          10 :                 ASSERT_EQ(oFeatureLayerPair.feature->GetFID(), nExpectedFID);
    1501          10 :                 nExpectedFID++;
    1502          10 :                 ASSERT_EQ(oFeatureLayerPair.layer, poLayer);
    1503             :             }
    1504           1 :             ASSERT_EQ(nExpectedFID, 10);
    1505             : 
    1506           1 :             nExpectedFID = 0;
    1507           5 :             OGR_FOR_EACH_FEATURE_BEGIN(hFeat,
    1508             :                                        reinterpret_cast<OGRLayerH>(poLayer))
    1509             :             {
    1510           5 :                 if (nExpectedFID == 0)
    1511             :                 {
    1512           1 :                     nExpectedFID = 1;
    1513           1 :                     continue;
    1514             :                 }
    1515           4 :                 ASSERT_EQ(OGR_F_GetFID(hFeat), nExpectedFID);
    1516           4 :                 nExpectedFID++;
    1517           4 :                 if (nExpectedFID == 5)
    1518           1 :                     break;
    1519             :             }
    1520           5 :             OGR_FOR_EACH_FEATURE_END(hFeat)
    1521           1 :             ASSERT_EQ(nExpectedFID, 5);
    1522             : 
    1523           1 :             auto oIter = poLayer->begin();
    1524           1 :             CPLPushErrorHandler(CPLQuietErrorHandler);
    1525             :             // Only one feature iterator can be active at a time
    1526           1 :             auto oIter2 = poLayer->begin();
    1527           1 :             CPLPopErrorHandler();
    1528           1 :             ASSERT_TRUE(!(oIter2 != poLayer->end()));
    1529           1 :             ASSERT_TRUE(oIter != poLayer->end());
    1530             :         }
    1531             : 
    1532           1 :         poDS.reset(GetGDALDriverManager()->GetDriverByName("MEM")->Create(
    1533             :             "", 0, 0, 0, GDT_Unknown, nullptr));
    1534           1 :         int nCountLayers = 0;
    1535           1 :         for (auto poLayer : poDS->GetLayers())
    1536             :         {
    1537           0 :             CPL_IGNORE_RET_VAL(poLayer);
    1538           0 :             nCountLayers++;
    1539             :         }
    1540           1 :         ASSERT_EQ(nCountLayers, 0);
    1541             : 
    1542           1 :         poDS->CreateLayer("foo");
    1543           1 :         poDS->CreateLayer("bar", nullptr);
    1544           3 :         for (auto poLayer : poDS->GetLayers())
    1545             :         {
    1546           2 :             if (nCountLayers == 0)
    1547             :             {
    1548           1 :                 EXPECT_STREQ(poLayer->GetName(), "foo")
    1549           0 :                     << "layer " << poLayer->GetName();
    1550             :             }
    1551           1 :             else if (nCountLayers == 1)
    1552             :             {
    1553           1 :                 EXPECT_STREQ(poLayer->GetName(), "bar")
    1554           0 :                     << "layer " << poLayer->GetName();
    1555             :             }
    1556           2 :             nCountLayers++;
    1557             :         }
    1558           1 :         ASSERT_EQ(nCountLayers, 2);
    1559             : 
    1560           1 :         auto layers = poDS->GetLayers();
    1561             :         {
    1562             :             // std::copy requires a InputIterator
    1563           1 :             std::vector<OGRLayer *> oTarget;
    1564           1 :             oTarget.resize(2);
    1565           1 :             std::copy(layers.begin(), layers.end(), oTarget.begin());
    1566           1 :             ASSERT_EQ(oTarget[0], layers[0]);
    1567           1 :             ASSERT_EQ(oTarget[1], layers[1]);
    1568             : 
    1569             :             // but in practice not necessarily uses the postincrement iterator.
    1570           1 :             oTarget.clear();
    1571           1 :             oTarget.resize(2);
    1572           1 :             auto input_iterator = layers.begin();
    1573           1 :             auto output_iterator = oTarget.begin();
    1574           3 :             while (input_iterator != layers.end())
    1575             :             {
    1576           2 :                 *output_iterator++ = *input_iterator++;
    1577             :             }
    1578           1 :             ASSERT_EQ(oTarget[0], layers[0]);
    1579           1 :             ASSERT_EQ(oTarget[1], layers[1]);
    1580             :         }
    1581             : 
    1582             :         // Test copy constructor
    1583             :         {
    1584           1 :             GDALDataset::Layers::Iterator srcIter(poDS->GetLayers().begin());
    1585           1 :             ++srcIter;
    1586           1 :             GDALDataset::Layers::Iterator newIter(srcIter);
    1587           1 :             srcIter = layers.begin();  // avoid Coverity Scan warning
    1588           1 :             ASSERT_EQ(*newIter, layers[1]);
    1589             :         }
    1590             : 
    1591             :         // Test assignment operator
    1592             :         {
    1593           1 :             GDALDataset::Layers::Iterator srcIter(poDS->GetLayers().begin());
    1594           1 :             ++srcIter;
    1595           1 :             GDALDataset::Layers::Iterator newIter;
    1596           1 :             newIter = srcIter;
    1597           1 :             srcIter = layers.begin();  // avoid Coverity Scan warning
    1598           1 :             ASSERT_EQ(*newIter, layers[1]);
    1599             :         }
    1600             : 
    1601             :         // Test move constructor
    1602             :         {
    1603           1 :             GDALDataset::Layers::Iterator srcIter(poDS->GetLayers().begin());
    1604           1 :             ++srcIter;
    1605           1 :             GDALDataset::Layers::Iterator newIter(std::move(srcIter));
    1606           1 :             ASSERT_EQ(*newIter, layers[1]);
    1607             :         }
    1608             : 
    1609             :         // Test move assignment operator
    1610             :         {
    1611           1 :             GDALDataset::Layers::Iterator srcIter(poDS->GetLayers().begin());
    1612           1 :             ++srcIter;
    1613           1 :             GDALDataset::Layers::Iterator newIter;
    1614           1 :             newIter = std::move(srcIter);
    1615           1 :             ASSERT_EQ(*newIter, layers[1]);
    1616             :         }
    1617             : 
    1618           1 :         const GDALDataset *poConstDS = poDS.get();
    1619           1 :         ASSERT_EQ(poConstDS->GetLayers().size(), 2U);
    1620           1 :         ASSERT_EQ(poConstDS->GetLayers()[0], poConstDS->GetLayer(0));
    1621           1 :         ASSERT_EQ(poConstDS->GetLayers()[static_cast<size_t>(0)],
    1622             :                   poConstDS->GetLayer(0));
    1623           1 :         ASSERT_EQ(poConstDS->GetLayers()["foo"], poConstDS->GetLayer(0));
    1624           1 :         nCountLayers = 0;
    1625           3 :         for (auto &&poLayer : poDS->GetLayers())
    1626             :         {
    1627           2 :             if (nCountLayers == 0)
    1628             :             {
    1629           1 :                 EXPECT_STREQ(poLayer->GetName(), "foo")
    1630           0 :                     << "layer " << poLayer->GetName();
    1631             :             }
    1632           1 :             else if (nCountLayers == 1)
    1633             :             {
    1634           1 :                 EXPECT_STREQ(poLayer->GetName(), "bar")
    1635           0 :                     << "layer " << poLayer->GetName();
    1636             :             }
    1637           2 :             nCountLayers++;
    1638             :         }
    1639           1 :         ASSERT_EQ(nCountLayers, 2);
    1640             : 
    1641           1 :         auto constLayers = poConstDS->GetLayers();
    1642             :         {
    1643             :             // std::copy requires a InputIterator
    1644           1 :             std::vector<const OGRLayer *> oTarget;
    1645           1 :             oTarget.resize(2);
    1646           1 :             std::copy(constLayers.begin(), constLayers.end(), oTarget.begin());
    1647           1 :             ASSERT_EQ(oTarget[0], constLayers[0]);
    1648           1 :             ASSERT_EQ(oTarget[1], constLayers[1]);
    1649             : 
    1650             :             // but in practice not necessarily uses the postincrement iterator.
    1651           1 :             oTarget.clear();
    1652           1 :             oTarget.resize(2);
    1653           1 :             auto input_iterator = constLayers.begin();
    1654           1 :             auto output_iterator = oTarget.begin();
    1655           3 :             while (input_iterator != constLayers.end())
    1656             :             {
    1657           2 :                 *output_iterator++ = *input_iterator++;
    1658             :             }
    1659           1 :             ASSERT_EQ(oTarget[0], constLayers[0]);
    1660           1 :             ASSERT_EQ(oTarget[1], constLayers[1]);
    1661             :         }
    1662             : 
    1663             :         // Test copy constructor
    1664             :         {
    1665           1 :             auto srcIter(poConstDS->GetLayers().begin());
    1666           1 :             ++srcIter;
    1667           1 :             auto newIter(srcIter);
    1668           1 :             srcIter = constLayers.begin();  // avoid Coverity Scan warning
    1669           1 :             ASSERT_EQ(*newIter, constLayers[1]);
    1670             :         }
    1671             : 
    1672             :         // Test assignment operator
    1673             :         {
    1674           1 :             auto srcIter(poConstDS->GetLayers().begin());
    1675           1 :             ++srcIter;
    1676           1 :             GDALDataset::ConstLayers::Iterator newIter;
    1677           1 :             newIter = srcIter;
    1678           1 :             srcIter = constLayers.begin();  // avoid Coverity Scan warning
    1679           1 :             ASSERT_EQ(*newIter, constLayers[1]);
    1680             :         }
    1681             : 
    1682             :         // Test move constructor
    1683             :         {
    1684           1 :             auto srcIter(poConstDS->GetLayers().begin());
    1685           1 :             ++srcIter;
    1686           1 :             auto newIter(std::move(srcIter));
    1687           1 :             ASSERT_EQ(*newIter, constLayers[1]);
    1688             :         }
    1689             : 
    1690             :         // Test move assignment operator
    1691             :         {
    1692           1 :             auto srcIter(poConstDS->GetLayers().begin());
    1693           1 :             ++srcIter;
    1694           1 :             GDALDataset::ConstLayers::Iterator newIter;
    1695           1 :             newIter = std::move(srcIter);
    1696           1 :             ASSERT_EQ(*newIter, constLayers[1]);
    1697             :         }
    1698             :     }
    1699             : }
    1700             : 
    1701             : // Test field iterator
    1702           4 : TEST_F(test_ogr, field_iterator)
    1703             : {
    1704           1 :     OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn();
    1705           1 :     poFeatureDefn->Reference();
    1706             :     {
    1707           2 :         OGRFieldDefn oFieldDefn("str_field", OFTString);
    1708           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1709             :     }
    1710             :     {
    1711           2 :         OGRFieldDefn oFieldDefn("int_field", OFTInteger);
    1712           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1713             :     }
    1714             :     {
    1715           2 :         OGRFieldDefn oFieldDefn("int64_field", OFTInteger64);
    1716           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1717             :     }
    1718             :     {
    1719           2 :         OGRFieldDefn oFieldDefn("double_field", OFTReal);
    1720           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1721             :     }
    1722             :     {
    1723           2 :         OGRFieldDefn oFieldDefn("null_field", OFTReal);
    1724           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1725             :     }
    1726             :     {
    1727           2 :         OGRFieldDefn oFieldDefn("unset_field", OFTReal);
    1728           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1729             :     }
    1730             :     {
    1731           2 :         OGRFieldDefn oFieldDefn("dt_field", OFTDateTime);
    1732           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1733             :     }
    1734             :     {
    1735           2 :         OGRFieldDefn oFieldDefn("strlist_field", OFTStringList);
    1736           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1737             :     }
    1738             :     {
    1739           2 :         OGRFieldDefn oFieldDefn("intlist_field", OFTIntegerList);
    1740           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1741             :     }
    1742             :     {
    1743           2 :         OGRFieldDefn oFieldDefn("int64list_field", OFTInteger64List);
    1744           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1745             :     }
    1746             :     {
    1747           2 :         OGRFieldDefn oFieldDefn("doublelist_field", OFTRealList);
    1748           1 :         poFeatureDefn->AddFieldDefn(&oFieldDefn);
    1749             :     }
    1750           1 :     OGRFeature oFeature(poFeatureDefn);
    1751             : 
    1752             :     {
    1753           1 :         OGRFeature oFeatureTmp(poFeatureDefn);
    1754           1 :         oFeatureTmp[0] = "bar";
    1755           2 :         ASSERT_STREQ(oFeatureTmp[0].GetString(), "bar");
    1756             :         {
    1757             :             // Proxy reference
    1758           1 :             auto &&x = oFeatureTmp[0];
    1759           1 :             auto &xRef(x);
    1760           1 :             x = xRef;
    1761           2 :             ASSERT_STREQ(oFeatureTmp[0].GetString(), "bar");
    1762             :         }
    1763             :         {
    1764           1 :             oFeatureTmp[0] = oFeatureTmp[0];
    1765           2 :             ASSERT_STREQ(oFeatureTmp[0].GetString(), "bar");
    1766             :         }
    1767             :         {
    1768             :             // Proxy reference
    1769           1 :             auto &&x = oFeatureTmp[0];
    1770           1 :             x = "baz";
    1771           1 :             ASSERT_STREQ(x.GetString(), "baz");
    1772             :         }
    1773           1 :         oFeatureTmp["str_field"] = std::string("foo");
    1774           1 :         oFeatureTmp["int_field"] = 123;
    1775           1 :         oFeatureTmp["int64_field"] = oFeatureTmp["int_field"];
    1776           1 :         ASSERT_EQ(oFeatureTmp["int64_field"].GetInteger64(), 123);
    1777           1 :         oFeatureTmp["int64_field"] = static_cast<GIntBig>(1234567890123);
    1778           1 :         oFeatureTmp["double_field"] = 123.45;
    1779           1 :         oFeatureTmp["null_field"].SetNull();
    1780           1 :         oFeatureTmp["unset_field"].clear();
    1781           1 :         oFeatureTmp["unset_field"].Unset();
    1782           1 :         oFeatureTmp["dt_field"].SetDateTime(2018, 4, 5, 12, 34, 56.75f, 0);
    1783           1 :         oFeatureTmp["strlist_field"] = CPLStringList().List();
    1784           1 :         oFeatureTmp["strlist_field"] = std::vector<std::string>();
    1785           3 :         oFeatureTmp["strlist_field"] = std::vector<std::string>{"foo", "bar"};
    1786             :         oFeatureTmp["strlist_field"] =
    1787           1 :             static_cast<CSLConstList>(oFeatureTmp["strlist_field"]);
    1788           1 :         ASSERT_EQ(
    1789             :             CSLCount(static_cast<CSLConstList>(oFeatureTmp["strlist_field"])),
    1790             :             2);
    1791           1 :         oFeatureTmp["intlist_field"] = std::vector<int>();
    1792           1 :         oFeatureTmp["intlist_field"] = std::vector<int>{12, 34};
    1793           1 :         oFeatureTmp["int64list_field"] = std::vector<GIntBig>();
    1794             :         oFeatureTmp["int64list_field"] =
    1795           1 :             std::vector<GIntBig>{1234567890123, 34};
    1796           1 :         oFeatureTmp["doublelist_field"] = std::vector<double>();
    1797           1 :         oFeatureTmp["doublelist_field"] = std::vector<double>{12.25, 56.75};
    1798             : 
    1799          12 :         for (const auto &oField : oFeatureTmp)
    1800             :         {
    1801          11 :             oFeature[oField.GetIndex()] = oField;
    1802             :         }
    1803             :     }
    1804             : 
    1805             :     {
    1806           1 :         int x = oFeature[1];
    1807           1 :         ASSERT_EQ(x, 123);
    1808             :     }
    1809             :     {
    1810           1 :         int x = oFeature["int_field"];
    1811           1 :         ASSERT_EQ(x, 123);
    1812             :     }
    1813             :     {
    1814           1 :         GIntBig x = oFeature["int64_field"];
    1815           1 :         ASSERT_EQ(x, static_cast<GIntBig>(1234567890123));
    1816             :     }
    1817             :     {
    1818           1 :         double x = oFeature["double_field"];
    1819           1 :         ASSERT_EQ(x, 123.45);
    1820             :     }
    1821             :     {
    1822           1 :         const char *x = oFeature["str_field"];
    1823           1 :         ASSERT_STREQ(x, "foo");
    1824             :     }
    1825           1 :     bool bExceptionHit = false;
    1826             :     try
    1827             :     {
    1828           1 :         oFeature["inexisting_field"];
    1829             :     }
    1830           1 :     catch (const OGRFeature::FieldNotFoundException &)
    1831             :     {
    1832           1 :         bExceptionHit = true;
    1833             :     }
    1834           1 :     ASSERT_TRUE(bExceptionHit);
    1835             : 
    1836           1 :     int iIter = 0;
    1837           1 :     const OGRFeature *poConstFeature = &oFeature;
    1838          12 :     for (const auto &oField : *poConstFeature)
    1839             :     {
    1840          11 :         ASSERT_EQ(oField.GetIndex(), iIter);
    1841          11 :         ASSERT_EQ(oField.GetDefn(), poFeatureDefn->GetFieldDefn(iIter));
    1842          22 :         ASSERT_EQ(CPLString(oField.GetName()),
    1843             :                   CPLString(oField.GetDefn()->GetNameRef()));
    1844          11 :         ASSERT_EQ(oField.GetType(), oField.GetDefn()->GetType());
    1845          11 :         ASSERT_EQ(oField.GetSubType(), oField.GetDefn()->GetSubType());
    1846          11 :         if (iIter == 0)
    1847             :         {
    1848           1 :             ASSERT_EQ(oField.IsUnset(), false);
    1849           1 :             ASSERT_EQ(oField.IsNull(), false);
    1850           2 :             ASSERT_EQ(CPLString(oField.GetRawValue()->String),
    1851             :                       CPLString("foo"));
    1852           2 :             ASSERT_EQ(CPLString(oField.GetString()), CPLString("foo"));
    1853           2 :             ASSERT_EQ(CPLString(oField.GetAsString()), CPLString("foo"));
    1854             :         }
    1855          10 :         else if (iIter == 1)
    1856             :         {
    1857           1 :             ASSERT_EQ(oField.GetRawValue()->Integer, 123);
    1858           1 :             ASSERT_EQ(oField.GetInteger(), 123);
    1859           1 :             ASSERT_EQ(oField.GetAsInteger(), 123);
    1860           1 :             ASSERT_EQ(oField.GetAsInteger64(), 123);
    1861           1 :             ASSERT_EQ(oField.GetAsDouble(), 123.0);
    1862           2 :             ASSERT_EQ(CPLString(oField.GetAsString()), CPLString("123"));
    1863             :         }
    1864           9 :         else if (iIter == 2)
    1865             :         {
    1866           1 :             ASSERT_EQ(oField.GetRawValue()->Integer64, 1234567890123);
    1867           1 :             ASSERT_EQ(oField.GetInteger64(), 1234567890123);
    1868           1 :             ASSERT_EQ(oField.GetAsInteger(), 2147483647);
    1869           1 :             ASSERT_EQ(oField.GetAsInteger64(), 1234567890123);
    1870           1 :             ASSERT_EQ(oField.GetAsDouble(), 1234567890123.0);
    1871           2 :             ASSERT_EQ(CPLString(oField.GetAsString()),
    1872             :                       CPLString("1234567890123"));
    1873             :         }
    1874           8 :         else if (iIter == 3)
    1875             :         {
    1876           1 :             ASSERT_EQ(oField.GetRawValue()->Real, 123.45);
    1877           1 :             ASSERT_EQ(oField.GetDouble(), 123.45);
    1878           1 :             ASSERT_EQ(oField.GetAsInteger(), 123);
    1879           1 :             ASSERT_EQ(oField.GetAsInteger64(), 123);
    1880           1 :             ASSERT_EQ(oField.GetAsDouble(), 123.45);
    1881           2 :             ASSERT_EQ(CPLString(oField.GetAsString()), CPLString("123.45"));
    1882             :         }
    1883           7 :         else if (iIter == 4)
    1884             :         {
    1885           1 :             ASSERT_EQ(oField.IsUnset(), false);
    1886           1 :             ASSERT_EQ(oField.IsNull(), true);
    1887             :         }
    1888           6 :         else if (iIter == 5)
    1889             :         {
    1890           1 :             ASSERT_EQ(oField.IsUnset(), true);
    1891           1 :             ASSERT_EQ(oField.empty(), true);
    1892           1 :             ASSERT_EQ(oField.IsNull(), false);
    1893             :         }
    1894           5 :         else if (iIter == 6)
    1895             :         {
    1896             :             int nYear, nMonth, nDay, nHour, nMin, nTZFlag;
    1897             :             float fSec;
    1898           1 :             ASSERT_EQ(oField.GetDateTime(&nYear, &nMonth, &nDay, &nHour, &nMin,
    1899             :                                          &fSec, &nTZFlag),
    1900             :                       true);
    1901           1 :             ASSERT_EQ(nYear, 2018);
    1902           1 :             ASSERT_EQ(nMonth, 4);
    1903           1 :             ASSERT_EQ(nDay, 5);
    1904           1 :             ASSERT_EQ(nHour, 12);
    1905           1 :             ASSERT_EQ(nMin, 34);
    1906           1 :             ASSERT_EQ(fSec, 56.75f);
    1907           1 :             ASSERT_EQ(nTZFlag, 0);
    1908             :         }
    1909           4 :         else if (iIter == 7)
    1910             :         {
    1911             :             std::vector<std::string> oExpected{std::string("foo"),
    1912           5 :                                                std::string("bar")};
    1913           1 :             decltype(oExpected) oGot = oField;
    1914           1 :             ASSERT_EQ(oGot.size(), oExpected.size());
    1915           3 :             for (size_t i = 0; i < oExpected.size(); i++)
    1916           2 :                 ASSERT_EQ(oGot[i], oExpected[i]);
    1917             :         }
    1918           3 :         else if (iIter == 8)
    1919             :         {
    1920           1 :             std::vector<int> oExpected{12, 34};
    1921           1 :             decltype(oExpected) oGot = oField;
    1922           1 :             ASSERT_EQ(oGot.size(), oExpected.size());
    1923           3 :             for (size_t i = 0; i < oExpected.size(); i++)
    1924           2 :                 ASSERT_EQ(oGot[i], oExpected[i]);
    1925             :         }
    1926           2 :         else if (iIter == 9)
    1927             :         {
    1928           1 :             std::vector<GIntBig> oExpected{1234567890123, 34};
    1929           1 :             decltype(oExpected) oGot = oField;
    1930           1 :             ASSERT_EQ(oGot.size(), oExpected.size());
    1931           3 :             for (size_t i = 0; i < oExpected.size(); i++)
    1932           2 :                 ASSERT_EQ(oGot[i], oExpected[i]);
    1933             :         }
    1934           1 :         else if (iIter == 10)
    1935             :         {
    1936           1 :             std::vector<double> oExpected{12.25, 56.75};
    1937           1 :             decltype(oExpected) oGot = oField;
    1938           1 :             ASSERT_EQ(oGot.size(), oExpected.size());
    1939           3 :             for (size_t i = 0; i < oExpected.size(); i++)
    1940           2 :                 ASSERT_EQ(oGot[i], oExpected[i]);
    1941             :         }
    1942          11 :         iIter++;
    1943             :     }
    1944           1 :     poFeatureDefn->Release();
    1945             : }
    1946             : 
    1947             : // Test OGRLinearRing::isPointOnRingBoundary()
    1948           4 : TEST_F(test_ogr, isPointOnRingBoundary)
    1949             : {
    1950           1 :     OGRPolygon oPoly;
    1951           1 :     const char *pszPoly = "POLYGON((10 9,11 10,10 11,9 10,10 9))";
    1952           1 :     oPoly.importFromWkt(&pszPoly);
    1953           1 :     auto poRing = oPoly.getExteriorRing();
    1954             : 
    1955             :     // On first vertex
    1956             :     {
    1957           1 :         OGRPoint p(10, 9);
    1958           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    1959             :     }
    1960             : 
    1961             :     // On second vertex
    1962             :     {
    1963           1 :         OGRPoint p(11, 10);
    1964           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    1965             :     }
    1966             : 
    1967             :     // Middle of first segment
    1968             :     {
    1969           1 :         OGRPoint p(10.5, 9.5);
    1970           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    1971             :     }
    1972             : 
    1973             :     // "Before" first segment
    1974             :     {
    1975           1 :         OGRPoint p(10 - 1, 9 - 1);
    1976           1 :         ASSERT_TRUE(!poRing->isPointOnRingBoundary(&p, false));
    1977             :     }
    1978             : 
    1979             :     // "After" first segment
    1980             :     {
    1981           1 :         OGRPoint p(11 + 1, 10 + 1);
    1982           1 :         ASSERT_TRUE(!poRing->isPointOnRingBoundary(&p, false));
    1983             :     }
    1984             : 
    1985             :     // On third vertex
    1986             :     {
    1987           1 :         OGRPoint p(10, 11);
    1988           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    1989             :     }
    1990             : 
    1991             :     // Middle of second segment
    1992             :     {
    1993           1 :         OGRPoint p(10.5, 10.5);
    1994           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    1995             :     }
    1996             : 
    1997             :     // On fourth vertex
    1998             :     {
    1999           1 :         OGRPoint p(9, 10);
    2000           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    2001             :     }
    2002             : 
    2003             :     // Middle of third segment
    2004             :     {
    2005           1 :         OGRPoint p(9.5, 10.5);
    2006           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    2007             :     }
    2008             : 
    2009             :     // Middle of fourth segment
    2010             :     {
    2011           1 :         OGRPoint p(9.5, 9.5);
    2012           1 :         ASSERT_TRUE(poRing->isPointOnRingBoundary(&p, false));
    2013             :     }
    2014             : }
    2015             : 
    2016             : // Test OGRGeometry::exportToWkt()
    2017           4 : TEST_F(test_ogr, OGRGeometry_exportToWkt)
    2018             : {
    2019           1 :     char *pszWKT = nullptr;
    2020           1 :     OGRPoint p(1, 2);
    2021           1 :     p.exportToWkt(&pszWKT);
    2022           1 :     ASSERT_TRUE(pszWKT != nullptr);
    2023           1 :     EXPECT_STREQ(pszWKT, "POINT (1 2)");
    2024           1 :     CPLFree(pszWKT);
    2025             : }
    2026             : 
    2027             : // Test OGRGeometry::clone()
    2028           4 : TEST_F(test_ogr, OGRGeometry_clone)
    2029             : {
    2030           1 :     const char *apszWKT[] = {
    2031             :         "POINT (0 0)",
    2032             :         "POINT ZM EMPTY",
    2033             :         "LINESTRING (0 0)",
    2034             :         "LINESTRING ZM EMPTY",
    2035             :         "POLYGON ((0 0),(0 0))",
    2036             :         "MULTIPOLYGON ZM EMPTY",
    2037             :         "MULTIPOINT ((0 0))",
    2038             :         "MULTIPOINT ZM EMPTY",
    2039             :         "MULTILINESTRING ((0 0))",
    2040             :         "MULTILINESTRING ZM EMPTY",
    2041             :         "MULTIPOLYGON (((0 0)))",
    2042             :         "MULTIPOLYGON ZM EMPTY",
    2043             :         "GEOMETRYCOLLECTION (POINT (0 0))",
    2044             :         "GEOMETRYCOLLECTION ZM EMPTY",
    2045             :         "CIRCULARSTRING (0 0,1 1,0 0)",
    2046             :         "CIRCULARSTRING Z EMPTY",
    2047             :         "CIRCULARSTRING ZM EMPTY",
    2048             :         "COMPOUNDCURVE ((0 0,1 1))",
    2049             :         "COMPOUNDCURVE ZM EMPTY",
    2050             :         "CURVEPOLYGON ((0 0,1 1,1 0,0 0))",
    2051             :         "CURVEPOLYGON ZM EMPTY",
    2052             :         "MULTICURVE ((0 0))",
    2053             :         "MULTICURVE ZM EMPTY",
    2054             :         "MULTISURFACE (((0 0)))",
    2055             :         "MULTISURFACE ZM EMPTY",
    2056             :         "TRIANGLE ((0 0,0 1,1 1,0 0))",
    2057             :         "TRIANGLE ZM EMPTY",
    2058             :         "POLYHEDRALSURFACE (((0 0,0 1,1 1,0 0)))",
    2059             :         "POLYHEDRALSURFACE ZM EMPTY",
    2060             :         "TIN (((0 0,0 1,1 1,0 0)))",
    2061             :         "TIN ZM EMPTY",
    2062             :     };
    2063           1 :     OGRSpatialReference oSRS;
    2064          32 :     for (const char *pszWKT : apszWKT)
    2065             :     {
    2066          31 :         OGRGeometry *poGeom = nullptr;
    2067          31 :         OGRGeometryFactory::createFromWkt(pszWKT, &oSRS, &poGeom);
    2068          31 :         auto poClone = poGeom->clone();
    2069          31 :         ASSERT_TRUE(poClone != nullptr);
    2070          31 :         char *outWKT = nullptr;
    2071          31 :         poClone->exportToWkt(&outWKT, wkbVariantIso);
    2072          31 :         EXPECT_STREQ(pszWKT, outWKT);
    2073          31 :         CPLFree(outWKT);
    2074          31 :         delete poClone;
    2075          31 :         delete poGeom;
    2076             :     }
    2077             : }
    2078             : 
    2079             : // Test OGRLineString::removePoint()
    2080           4 : TEST_F(test_ogr, OGRLineString_removePoint)
    2081             : {
    2082             :     {
    2083           1 :         OGRLineString ls;
    2084           1 :         ls.addPoint(0, 1);
    2085           1 :         ls.addPoint(2, 3);
    2086           1 :         ls.addPoint(4, 5);
    2087           1 :         ASSERT_TRUE(!ls.removePoint(-1));
    2088           1 :         ASSERT_TRUE(!ls.removePoint(3));
    2089           1 :         ASSERT_EQ(ls.getNumPoints(), 3);
    2090           1 :         ASSERT_TRUE(ls.removePoint(1));
    2091           1 :         ASSERT_EQ(ls.getNumPoints(), 2);
    2092           1 :         ASSERT_EQ(ls.getX(0), 0.0);
    2093           1 :         ASSERT_EQ(ls.getY(0), 1.0);
    2094           1 :         ASSERT_EQ(ls.getX(1), 4.0);
    2095           1 :         ASSERT_EQ(ls.getY(1), 5.0);
    2096           1 :         ASSERT_TRUE(ls.removePoint(1));
    2097           1 :         ASSERT_EQ(ls.getNumPoints(), 1);
    2098           1 :         ASSERT_TRUE(ls.removePoint(0));
    2099           1 :         ASSERT_EQ(ls.getNumPoints(), 0);
    2100             :     }
    2101             :     {
    2102             :         // With Z, M
    2103           1 :         OGRLineString ls;
    2104           1 :         ls.addPoint(0, 1, 20, 30);
    2105           1 :         ls.addPoint(2, 3, 40, 50);
    2106           1 :         ls.addPoint(4, 5, 60, 70);
    2107           1 :         ASSERT_TRUE(!ls.removePoint(-1));
    2108           1 :         ASSERT_TRUE(!ls.removePoint(3));
    2109           1 :         ASSERT_EQ(ls.getNumPoints(), 3);
    2110           1 :         ASSERT_TRUE(ls.removePoint(1));
    2111           1 :         ASSERT_EQ(ls.getNumPoints(), 2);
    2112           1 :         ASSERT_EQ(ls.getX(0), 0.0);
    2113           1 :         ASSERT_EQ(ls.getY(0), 1.0);
    2114           1 :         ASSERT_EQ(ls.getZ(0), 20.0);
    2115           1 :         ASSERT_EQ(ls.getM(0), 30.0);
    2116           1 :         ASSERT_EQ(ls.getX(1), 4.0);
    2117           1 :         ASSERT_EQ(ls.getY(1), 5.0);
    2118           1 :         ASSERT_EQ(ls.getZ(1), 60.0);
    2119           1 :         ASSERT_EQ(ls.getM(1), 70.0);
    2120           1 :         ASSERT_TRUE(ls.removePoint(1));
    2121           1 :         ASSERT_EQ(ls.getNumPoints(), 1);
    2122           1 :         ASSERT_TRUE(ls.removePoint(0));
    2123           1 :         ASSERT_EQ(ls.getNumPoints(), 0);
    2124             :     }
    2125             : }
    2126             : 
    2127             : // Test effect of MarkSuppressOnClose() on DXF
    2128           4 : TEST_F(test_ogr, DXF_MarkSuppressOnClose)
    2129             : {
    2130           1 :     CPLString tmpFilename(CPLGenerateTempFilename(nullptr));
    2131           1 :     tmpFilename += ".dxf";
    2132           1 :     auto poDrv = GDALDriver::FromHandle(GDALGetDriverByName("DXF"));
    2133           1 :     if (poDrv)
    2134             :     {
    2135             :         auto poDS(GDALDatasetUniquePtr(
    2136           1 :             poDrv->Create(tmpFilename, 0, 0, 0, GDT_Unknown, nullptr)));
    2137           1 :         ASSERT_TRUE(poDS != nullptr);
    2138             : 
    2139             :         OGRLayer *poLayer =
    2140           1 :             poDS->CreateLayer("test", nullptr, wkbPoint, nullptr);
    2141           1 :         ASSERT_TRUE(poLayer != nullptr);
    2142             : 
    2143         101 :         for (double x = 0; x < 100; x++)
    2144             :         {
    2145             :             OGRFeature *poFeature =
    2146         100 :                 OGRFeature::CreateFeature(poLayer->GetLayerDefn());
    2147         100 :             ASSERT_TRUE(poFeature != nullptr);
    2148         100 :             OGRPoint pt(x, 42);
    2149         100 :             ASSERT_EQ(OGRERR_NONE, poFeature->SetGeometry(&pt));
    2150         100 :             ASSERT_EQ(OGRERR_NONE, poLayer->CreateFeature(poFeature));
    2151         100 :             OGRFeature::DestroyFeature(poFeature);
    2152             :         }
    2153             : 
    2154           1 :         poDS->MarkSuppressOnClose();
    2155             : 
    2156           1 :         poDS.reset();
    2157             :         VSIStatBufL sStat;
    2158           1 :         ASSERT_TRUE(0 != VSIStatL(tmpFilename, &sStat));
    2159             :     }
    2160             : }
    2161             : 
    2162             : // Test OGREnvelope
    2163           4 : TEST_F(test_ogr, OGREnvelope)
    2164             : {
    2165           1 :     OGREnvelope s1;
    2166           1 :     ASSERT_TRUE(!s1.IsInit());
    2167             :     {
    2168           1 :         OGREnvelope s2(s1);
    2169           1 :         ASSERT_TRUE(s1 == s2);
    2170           1 :         ASSERT_TRUE(!(s1 != s2));
    2171             :     }
    2172             : 
    2173           1 :     s1.MinX = 0;
    2174           1 :     s1.MinY = 1;
    2175           1 :     s1.MaxX = 2;
    2176           1 :     s1.MaxY = 3;
    2177           1 :     ASSERT_TRUE(s1.IsInit());
    2178             :     {
    2179           1 :         OGREnvelope s2(s1);
    2180           1 :         ASSERT_TRUE(s1 == s2);
    2181           1 :         ASSERT_TRUE(!(s1 != s2));
    2182           1 :         s2.MinX += 1;
    2183           1 :         ASSERT_TRUE(s1 != s2);
    2184           1 :         ASSERT_TRUE(!(s1 == s2));
    2185             :     }
    2186             : }
    2187             : 
    2188             : // Test OGREnvelope3D
    2189           4 : TEST_F(test_ogr, OGREnvelope3D)
    2190             : {
    2191           1 :     OGREnvelope3D s1;
    2192           1 :     EXPECT_TRUE(!s1.IsInit());
    2193             :     {
    2194           1 :         OGREnvelope3D s2(s1);
    2195           1 :         EXPECT_TRUE(s1 == s2);
    2196           1 :         EXPECT_TRUE(!(s1 != s2));
    2197             :     }
    2198             : 
    2199           1 :     s1.MinX = 0;
    2200           1 :     s1.MinY = 1;
    2201           1 :     s1.MaxX = 2;
    2202           1 :     s1.MaxY = 3;
    2203           1 :     EXPECT_TRUE(s1.IsInit());
    2204           1 :     EXPECT_FALSE(s1.Is3D());
    2205           1 :     s1.MinZ = 4;
    2206           1 :     s1.MaxZ = 5;
    2207           1 :     EXPECT_TRUE(s1.Is3D());
    2208             :     {
    2209           1 :         OGREnvelope3D s2(s1);
    2210           1 :         EXPECT_TRUE(s1 == s2);
    2211           1 :         EXPECT_TRUE(!(s1 != s2));
    2212           1 :         s2.MinX += 1;
    2213           1 :         EXPECT_TRUE(s1 != s2);
    2214           1 :         EXPECT_TRUE(!(s1 == s2));
    2215             :     }
    2216           1 : }
    2217             : 
    2218             : // Test OGRStyleMgr::InitStyleString() with a style name
    2219             : // (https://github.com/OSGeo/gdal/issues/5555)
    2220           4 : TEST_F(test_ogr, InitStyleString_with_style_name)
    2221             : {
    2222           1 :     OGRStyleTableH hStyleTable = OGR_STBL_Create();
    2223           1 :     OGR_STBL_AddStyle(hStyleTable, "@my_style", "PEN(c:#FF0000,w:5px)");
    2224           1 :     OGRStyleMgrH hSM = OGR_SM_Create(hStyleTable);
    2225           1 :     EXPECT_EQ(OGR_SM_GetPartCount(hSM, nullptr), 0);
    2226           1 :     EXPECT_TRUE(OGR_SM_InitStyleString(hSM, "@my_style"));
    2227           1 :     EXPECT_EQ(OGR_SM_GetPartCount(hSM, nullptr), 1);
    2228           1 :     EXPECT_TRUE(!OGR_SM_InitStyleString(hSM, "@i_do_not_exist"));
    2229           1 :     OGR_SM_Destroy(hSM);
    2230           1 :     OGR_STBL_Destroy(hStyleTable);
    2231           1 : }
    2232             : 
    2233             : // Test OGR_L_GetArrowStream
    2234           4 : TEST_F(test_ogr, OGR_L_GetArrowStream)
    2235             : {
    2236             :     auto poDS = std::unique_ptr<GDALDataset>(
    2237             :         GetGDALDriverManager()->GetDriverByName("MEM")->Create(
    2238           1 :             "", 0, 0, 0, GDT_Unknown, nullptr));
    2239           1 :     auto poLayer = poDS->CreateLayer("test");
    2240             :     {
    2241           2 :         OGRFieldDefn oFieldDefn("str", OFTString);
    2242           1 :         poLayer->CreateField(&oFieldDefn);
    2243             :     }
    2244             :     {
    2245           2 :         OGRFieldDefn oFieldDefn("bool", OFTInteger);
    2246           1 :         oFieldDefn.SetSubType(OFSTBoolean);
    2247           1 :         poLayer->CreateField(&oFieldDefn);
    2248             :     }
    2249             :     {
    2250           2 :         OGRFieldDefn oFieldDefn("int16", OFTInteger);
    2251           1 :         oFieldDefn.SetSubType(OFSTInt16);
    2252           1 :         poLayer->CreateField(&oFieldDefn);
    2253             :     }
    2254             :     {
    2255           2 :         OGRFieldDefn oFieldDefn("int32", OFTInteger);
    2256           1 :         poLayer->CreateField(&oFieldDefn);
    2257             :     }
    2258             :     {
    2259           2 :         OGRFieldDefn oFieldDefn("int64", OFTInteger64);
    2260           1 :         poLayer->CreateField(&oFieldDefn);
    2261             :     }
    2262             :     {
    2263           2 :         OGRFieldDefn oFieldDefn("float32", OFTReal);
    2264           1 :         oFieldDefn.SetSubType(OFSTFloat32);
    2265           1 :         poLayer->CreateField(&oFieldDefn);
    2266             :     }
    2267             :     {
    2268           2 :         OGRFieldDefn oFieldDefn("float64", OFTReal);
    2269           1 :         poLayer->CreateField(&oFieldDefn);
    2270             :     }
    2271             :     {
    2272           2 :         OGRFieldDefn oFieldDefn("date", OFTDate);
    2273           1 :         poLayer->CreateField(&oFieldDefn);
    2274             :     }
    2275             :     {
    2276           2 :         OGRFieldDefn oFieldDefn("time", OFTTime);
    2277           1 :         poLayer->CreateField(&oFieldDefn);
    2278             :     }
    2279             :     {
    2280           2 :         OGRFieldDefn oFieldDefn("datetime", OFTDateTime);
    2281           1 :         poLayer->CreateField(&oFieldDefn);
    2282             :     }
    2283             :     {
    2284           2 :         OGRFieldDefn oFieldDefn("binary", OFTBinary);
    2285           1 :         poLayer->CreateField(&oFieldDefn);
    2286             :     }
    2287             :     {
    2288           2 :         OGRFieldDefn oFieldDefn("strlist", OFTStringList);
    2289           1 :         poLayer->CreateField(&oFieldDefn);
    2290             :     }
    2291             :     {
    2292           2 :         OGRFieldDefn oFieldDefn("boollist", OFTIntegerList);
    2293           1 :         oFieldDefn.SetSubType(OFSTBoolean);
    2294           1 :         poLayer->CreateField(&oFieldDefn);
    2295             :     }
    2296             :     {
    2297           2 :         OGRFieldDefn oFieldDefn("int16list", OFTIntegerList);
    2298           1 :         oFieldDefn.SetSubType(OFSTInt16);
    2299           1 :         poLayer->CreateField(&oFieldDefn);
    2300             :     }
    2301             :     {
    2302           2 :         OGRFieldDefn oFieldDefn("int32list", OFTIntegerList);
    2303           1 :         poLayer->CreateField(&oFieldDefn);
    2304             :     }
    2305             :     {
    2306           2 :         OGRFieldDefn oFieldDefn("int64list", OFTInteger64List);
    2307           1 :         poLayer->CreateField(&oFieldDefn);
    2308             :     }
    2309             :     {
    2310           2 :         OGRFieldDefn oFieldDefn("float32list", OFTRealList);
    2311           1 :         oFieldDefn.SetSubType(OFSTFloat32);
    2312           1 :         poLayer->CreateField(&oFieldDefn);
    2313             :     }
    2314             :     {
    2315           2 :         OGRFieldDefn oFieldDefn("float64list", OFTRealList);
    2316           1 :         poLayer->CreateField(&oFieldDefn);
    2317             :     }
    2318           1 :     auto poFDefn = poLayer->GetLayerDefn();
    2319             :     struct ArrowArrayStream stream;
    2320           1 :     ASSERT_TRUE(
    2321             :         OGR_L_GetArrowStream(OGRLayer::ToHandle(poLayer), &stream, nullptr));
    2322             :     {
    2323             :         // Cannot start a new stream while one is active
    2324             :         struct ArrowArrayStream stream2;
    2325           1 :         CPLPushErrorHandler(CPLQuietErrorHandler);
    2326           1 :         ASSERT_TRUE(OGR_L_GetArrowStream(OGRLayer::ToHandle(poLayer), &stream2,
    2327             :                                          nullptr) == false);
    2328           1 :         CPLPopErrorHandler();
    2329             :     }
    2330           1 :     ASSERT_TRUE(stream.release != nullptr);
    2331             : 
    2332             :     struct ArrowSchema schema;
    2333           1 :     CPLErrorReset();
    2334           1 :     ASSERT_TRUE(stream.get_last_error(&stream) == nullptr);
    2335           1 :     ASSERT_EQ(stream.get_schema(&stream, &schema), 0);
    2336           1 :     ASSERT_TRUE(stream.get_last_error(&stream) == nullptr);
    2337           1 :     ASSERT_TRUE(schema.release != nullptr);
    2338           1 :     ASSERT_EQ(schema.n_children,
    2339             :               1 + poFDefn->GetFieldCount() + poFDefn->GetGeomFieldCount());
    2340           1 :     schema.release(&schema);
    2341             : 
    2342             :     struct ArrowArray array;
    2343             :     // Next batch ==> End of stream
    2344           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2345           1 :     ASSERT_TRUE(array.release == nullptr);
    2346             : 
    2347             :     // Release stream
    2348           1 :     stream.release(&stream);
    2349             : 
    2350             :     {
    2351           1 :         auto poFeature = std::unique_ptr<OGRFeature>(new OGRFeature(poFDefn));
    2352           1 :         poFeature->SetField("bool", 1);
    2353           1 :         poFeature->SetField("int16", -12345);
    2354           1 :         poFeature->SetField("int32", 12345678);
    2355           1 :         poFeature->SetField("int64", static_cast<GIntBig>(12345678901234));
    2356           1 :         poFeature->SetField("float32", 1.25);
    2357           1 :         poFeature->SetField("float64", 1.250123);
    2358           1 :         poFeature->SetField("str", "abc");
    2359           1 :         poFeature->SetField("date", "2022-05-31");
    2360           1 :         poFeature->SetField("time", "12:34:56.789");
    2361           1 :         poFeature->SetField("datetime", "2022-05-31T12:34:56.789Z");
    2362           1 :         poFeature->SetField("boollist", "[False,True]");
    2363           1 :         poFeature->SetField("int16list", "[-12345,12345]");
    2364           1 :         poFeature->SetField("int32list", "[-12345678,12345678]");
    2365           1 :         poFeature->SetField("int64list", "[-12345678901234,12345678901234]");
    2366           1 :         poFeature->SetField("float32list", "[-1.25,1.25]");
    2367           1 :         poFeature->SetField("float64list", "[-1.250123,1.250123]");
    2368           1 :         poFeature->SetField("strlist", "[\"abc\",\"defghi\"]");
    2369           1 :         poFeature->SetField(poFDefn->GetFieldIndex("binary"), 2, "\xDE\xAD");
    2370           1 :         OGRGeometry *poGeom = nullptr;
    2371           1 :         OGRGeometryFactory::createFromWkt("POINT(1 2)", nullptr, &poGeom);
    2372           1 :         poFeature->SetGeometryDirectly(poGeom);
    2373           1 :         ASSERT_EQ(poLayer->CreateFeature(poFeature.get()), OGRERR_NONE);
    2374             :     }
    2375             : 
    2376             :     // Get a new stream now that we've released it
    2377           1 :     ASSERT_TRUE(
    2378             :         OGR_L_GetArrowStream(OGRLayer::ToHandle(poLayer), &stream, nullptr));
    2379           1 :     ASSERT_TRUE(stream.release != nullptr);
    2380             : 
    2381           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2382           1 :     ASSERT_TRUE(array.release != nullptr);
    2383           1 :     ASSERT_EQ(array.n_children,
    2384             :               1 + poFDefn->GetFieldCount() + poFDefn->GetGeomFieldCount());
    2385           1 :     ASSERT_EQ(array.length, poLayer->GetFeatureCount(false));
    2386           1 :     ASSERT_EQ(array.null_count, 0);
    2387           1 :     ASSERT_EQ(array.n_buffers, 1);
    2388           1 :     ASSERT_TRUE(array.buffers[0] == nullptr);  // no bitmap
    2389          21 :     for (int i = 0; i < array.n_children; i++)
    2390             :     {
    2391          20 :         ASSERT_TRUE(array.children[i]->release != nullptr);
    2392          20 :         ASSERT_EQ(array.children[i]->length, array.length);
    2393          20 :         ASSERT_TRUE(array.children[i]->n_buffers >= 2);
    2394          20 :         ASSERT_TRUE(array.children[i]->buffers[0] == nullptr);  // no bitmap
    2395          20 :         ASSERT_EQ(array.children[i]->null_count, 0);
    2396          20 :         ASSERT_TRUE(array.children[i]->buffers[1] != nullptr);
    2397          20 :         if (array.children[i]->n_buffers == 3)
    2398             :         {
    2399           3 :             ASSERT_TRUE(array.children[i]->buffers[2] != nullptr);
    2400             :         }
    2401             :     }
    2402           1 :     array.release(&array);
    2403             : 
    2404             :     // Next batch ==> End of stream
    2405           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2406           1 :     ASSERT_TRUE(array.release == nullptr);
    2407             : 
    2408             :     // Release stream
    2409           1 :     stream.release(&stream);
    2410             : 
    2411             :     // Insert 2 empty features
    2412             :     {
    2413           1 :         auto poFeature = std::unique_ptr<OGRFeature>(new OGRFeature(poFDefn));
    2414           1 :         ASSERT_EQ(poLayer->CreateFeature(poFeature.get()), OGRERR_NONE);
    2415             :     }
    2416             : 
    2417             :     {
    2418           1 :         auto poFeature = std::unique_ptr<OGRFeature>(new OGRFeature(poFDefn));
    2419           1 :         ASSERT_EQ(poLayer->CreateFeature(poFeature.get()), OGRERR_NONE);
    2420             :     }
    2421             : 
    2422             :     // Get a new stream now that we've released it
    2423             :     {
    2424             :         char **papszOptions =
    2425           1 :             CSLSetNameValue(nullptr, "MAX_FEATURES_IN_BATCH", "2");
    2426           1 :         ASSERT_TRUE(OGR_L_GetArrowStream(OGRLayer::ToHandle(poLayer), &stream,
    2427             :                                          papszOptions));
    2428           1 :         CSLDestroy(papszOptions);
    2429             :     }
    2430           1 :     ASSERT_TRUE(stream.release != nullptr);
    2431             : 
    2432           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2433           1 :     ASSERT_TRUE(array.release != nullptr);
    2434           1 :     ASSERT_EQ(array.n_children,
    2435             :               1 + poFDefn->GetFieldCount() + poFDefn->GetGeomFieldCount());
    2436           1 :     ASSERT_EQ(array.length, 2);
    2437          21 :     for (int i = 0; i < array.n_children; i++)
    2438             :     {
    2439          20 :         ASSERT_TRUE(array.children[i]->release != nullptr);
    2440          20 :         ASSERT_EQ(array.children[i]->length, array.length);
    2441          20 :         ASSERT_TRUE(array.children[i]->n_buffers >= 2);
    2442          20 :         if (i > 0)
    2443             :         {
    2444          19 :             ASSERT_TRUE(array.children[i]->buffers[0] !=
    2445             :                         nullptr);  // we have a bitmap
    2446          19 :             ASSERT_EQ(array.children[i]->null_count, 1);
    2447             :         }
    2448          20 :         ASSERT_TRUE(array.children[i]->buffers[1] != nullptr);
    2449          20 :         if (array.children[i]->n_buffers == 3)
    2450             :         {
    2451           3 :             ASSERT_TRUE(array.children[i]->buffers[2] != nullptr);
    2452             :         }
    2453             :     }
    2454           1 :     array.release(&array);
    2455             : 
    2456             :     // Next batch
    2457           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2458           1 :     ASSERT_TRUE(array.release != nullptr);
    2459           1 :     ASSERT_EQ(array.n_children,
    2460             :               1 + poFDefn->GetFieldCount() + poFDefn->GetGeomFieldCount());
    2461           1 :     ASSERT_EQ(array.length, 1);
    2462           1 :     array.release(&array);
    2463             : 
    2464             :     // Next batch ==> End of stream
    2465           1 :     ASSERT_EQ(stream.get_next(&stream, &array), 0);
    2466           1 :     ASSERT_TRUE(array.release == nullptr);
    2467             : 
    2468             :     // Release stream
    2469           1 :     stream.release(&stream);
    2470             : 
    2471             :     // Get a new stream now that we've released it
    2472           1 :     ASSERT_TRUE(
    2473             :         OGR_L_GetArrowStream(OGRLayer::ToHandle(poLayer), &stream, nullptr));
    2474           1 :     ASSERT_TRUE(stream.release != nullptr);
    2475             : 
    2476             :     // Free dataset & layer
    2477           1 :     poDS.reset();
    2478             : 
    2479             :     // Test releasing the stream after the dataset/layer has been closed
    2480           1 :     CPLPushErrorHandler(CPLQuietErrorHandler);
    2481           1 :     CPLErrorReset();
    2482           1 :     ASSERT_TRUE(stream.get_schema(&stream, &schema) != 0);
    2483           1 :     ASSERT_TRUE(stream.get_last_error(&stream) != nullptr);
    2484           1 :     ASSERT_TRUE(stream.get_next(&stream, &array) != 0);
    2485           1 :     CPLPopErrorHandler();
    2486           1 :     stream.release(&stream);
    2487             : }
    2488             : 
    2489             : // Test field domain cloning
    2490           4 : TEST_F(test_ogr, field_domain_cloning)
    2491             : {
    2492             :     // range domain
    2493             :     OGRField min;
    2494           1 :     min.Real = 5.5;
    2495             :     OGRField max;
    2496           1 :     max.Real = 6.5;
    2497             :     OGRRangeFieldDomain oRange("name", "description", OGRFieldType::OFTReal,
    2498             :                                OGRFieldSubType::OFSTBoolean, min, true, max,
    2499           2 :                                true);
    2500           1 :     oRange.SetMergePolicy(OGRFieldDomainMergePolicy::OFDMP_GEOMETRY_WEIGHTED);
    2501           1 :     oRange.SetSplitPolicy(OGRFieldDomainSplitPolicy::OFDSP_GEOMETRY_RATIO);
    2502           1 :     std::unique_ptr<OGRRangeFieldDomain> poClonedRange(oRange.Clone());
    2503           1 :     ASSERT_EQ(poClonedRange->GetName(), oRange.GetName());
    2504           1 :     ASSERT_EQ(poClonedRange->GetDescription(), oRange.GetDescription());
    2505           1 :     bool originalInclusive = false;
    2506           1 :     bool cloneInclusive = false;
    2507           1 :     ASSERT_EQ(poClonedRange->GetMin(originalInclusive).Real,
    2508             :               oRange.GetMin(cloneInclusive).Real);
    2509           1 :     ASSERT_EQ(originalInclusive, cloneInclusive);
    2510           1 :     ASSERT_EQ(poClonedRange->GetMax(originalInclusive).Real,
    2511             :               oRange.GetMax(cloneInclusive).Real);
    2512           1 :     ASSERT_EQ(originalInclusive, cloneInclusive);
    2513           1 :     ASSERT_EQ(poClonedRange->GetFieldType(), oRange.GetFieldType());
    2514           1 :     ASSERT_EQ(poClonedRange->GetFieldSubType(), oRange.GetFieldSubType());
    2515           1 :     ASSERT_EQ(poClonedRange->GetSplitPolicy(), oRange.GetSplitPolicy());
    2516           1 :     ASSERT_EQ(poClonedRange->GetMergePolicy(), oRange.GetMergePolicy());
    2517             : 
    2518             :     // glob domain
    2519             :     OGRGlobFieldDomain oGlob("name", "description", OGRFieldType::OFTString,
    2520           2 :                              OGRFieldSubType::OFSTBoolean, "*a*");
    2521           1 :     oGlob.SetMergePolicy(OGRFieldDomainMergePolicy::OFDMP_GEOMETRY_WEIGHTED);
    2522           1 :     oGlob.SetSplitPolicy(OGRFieldDomainSplitPolicy::OFDSP_GEOMETRY_RATIO);
    2523           1 :     std::unique_ptr<OGRGlobFieldDomain> poClonedGlob(oGlob.Clone());
    2524           1 :     ASSERT_EQ(poClonedGlob->GetName(), oGlob.GetName());
    2525           1 :     ASSERT_EQ(poClonedGlob->GetDescription(), oGlob.GetDescription());
    2526           1 :     ASSERT_EQ(poClonedGlob->GetGlob(), oGlob.GetGlob());
    2527           1 :     ASSERT_EQ(poClonedGlob->GetFieldType(), oGlob.GetFieldType());
    2528           1 :     ASSERT_EQ(poClonedGlob->GetFieldSubType(), oGlob.GetFieldSubType());
    2529           1 :     ASSERT_EQ(poClonedGlob->GetSplitPolicy(), oGlob.GetSplitPolicy());
    2530           1 :     ASSERT_EQ(poClonedGlob->GetMergePolicy(), oGlob.GetMergePolicy());
    2531             : 
    2532             :     // coded value domain
    2533             :     OGRCodedFieldDomain oCoded("name", "description", OGRFieldType::OFTString,
    2534           2 :                                OGRFieldSubType::OFSTBoolean, {OGRCodedValue()});
    2535           1 :     oCoded.SetMergePolicy(OGRFieldDomainMergePolicy::OFDMP_GEOMETRY_WEIGHTED);
    2536           1 :     oCoded.SetSplitPolicy(OGRFieldDomainSplitPolicy::OFDSP_GEOMETRY_RATIO);
    2537           1 :     std::unique_ptr<OGRCodedFieldDomain> poClonedCoded(oCoded.Clone());
    2538           1 :     ASSERT_EQ(poClonedCoded->GetName(), oCoded.GetName());
    2539           1 :     ASSERT_EQ(poClonedCoded->GetDescription(), oCoded.GetDescription());
    2540           1 :     ASSERT_EQ(poClonedCoded->GetFieldType(), oCoded.GetFieldType());
    2541           1 :     ASSERT_EQ(poClonedCoded->GetFieldSubType(), oCoded.GetFieldSubType());
    2542           1 :     ASSERT_EQ(poClonedCoded->GetSplitPolicy(), oCoded.GetSplitPolicy());
    2543           1 :     ASSERT_EQ(poClonedCoded->GetMergePolicy(), oCoded.GetMergePolicy());
    2544             : }
    2545             : 
    2546             : // Test field comments
    2547           4 : TEST_F(test_ogr, field_comments)
    2548             : {
    2549           1 :     OGRFieldDefn oFieldDefn("field1", OFTString);
    2550           1 :     ASSERT_EQ(oFieldDefn.GetComment(), "");
    2551           1 :     oFieldDefn.SetComment("my comment");
    2552           1 :     ASSERT_EQ(oFieldDefn.GetComment(), "my comment");
    2553             : 
    2554           1 :     OGRFieldDefn oFieldDefn2(&oFieldDefn);
    2555           1 :     ASSERT_EQ(oFieldDefn2.GetComment(), "my comment");
    2556           1 :     ASSERT_TRUE(oFieldDefn.IsSame(&oFieldDefn2));
    2557             : 
    2558           1 :     oFieldDefn2.SetComment("my comment 2");
    2559           1 :     ASSERT_FALSE(oFieldDefn.IsSame(&oFieldDefn2));
    2560             : }
    2561             : 
    2562             : // Test OGRFeatureDefn C++ GetFields() iterator
    2563           4 : TEST_F(test_ogr, feature_defn_fields_iterator)
    2564             : {
    2565           2 :     OGRFeatureDefn oFDefn;
    2566             :     {
    2567           2 :         OGRFieldDefn oFieldDefn("field1", OFTString);
    2568           1 :         oFDefn.AddFieldDefn(&oFieldDefn);
    2569             :     }
    2570             :     {
    2571           2 :         OGRFieldDefn oFieldDefn("field2", OFTString);
    2572           1 :         oFDefn.AddFieldDefn(&oFieldDefn);
    2573             :     }
    2574           1 :     EXPECT_EQ(oFDefn.GetFields().size(),
    2575             :               static_cast<size_t>(oFDefn.GetFieldCount()));
    2576           1 :     int i = 0;
    2577           3 :     for (const auto *poFieldDefn : oFDefn.GetFields())
    2578             :     {
    2579           2 :         EXPECT_EQ(oFDefn.GetFields()[i], oFDefn.GetFieldDefn(i));
    2580           2 :         EXPECT_EQ(poFieldDefn, oFDefn.GetFieldDefn(i));
    2581           2 :         ++i;
    2582             :     }
    2583           1 :     EXPECT_EQ(i, oFDefn.GetFieldCount());
    2584           1 : }
    2585             : 
    2586             : // Test OGRFeatureDefn C++ GetGeomFields() iterator
    2587           4 : TEST_F(test_ogr, feature_defn_geomfields_iterator)
    2588             : {
    2589           2 :     OGRFeatureDefn oFDefn;
    2590             :     {
    2591           2 :         OGRGeomFieldDefn oGeomFieldDefn("field1", wkbUnknown);
    2592           1 :         oFDefn.AddGeomFieldDefn(&oGeomFieldDefn);
    2593             :     }
    2594             :     {
    2595           2 :         OGRGeomFieldDefn oGeomFieldDefn("field2", wkbUnknown);
    2596           1 :         oFDefn.AddGeomFieldDefn(&oGeomFieldDefn);
    2597             :     }
    2598           1 :     EXPECT_EQ(oFDefn.GetGeomFields().size(),
    2599             :               static_cast<size_t>(oFDefn.GetGeomFieldCount()));
    2600           1 :     int i = 0;
    2601           4 :     for (const auto *poGeomFieldDefn : oFDefn.GetGeomFields())
    2602             :     {
    2603           3 :         EXPECT_EQ(oFDefn.GetGeomFields()[i], oFDefn.GetGeomFieldDefn(i));
    2604           3 :         EXPECT_EQ(poGeomFieldDefn, oFDefn.GetGeomFieldDefn(i));
    2605           3 :         ++i;
    2606             :     }
    2607           1 :     EXPECT_EQ(i, oFDefn.GetGeomFieldCount());
    2608           1 : }
    2609             : 
    2610             : // Test OGRGeomFieldDefn copy constructor
    2611           4 : TEST_F(test_ogr, geom_field_defn_copy_constructor)
    2612             : {
    2613             :     {
    2614           2 :         OGRGeomFieldDefn oGeomFieldDefn("field1", wkbPoint);
    2615           1 :         oGeomFieldDefn.SetNullable(false);
    2616           2 :         OGRGeomFieldDefn oGeomFieldDefn2("field2", wkbLineString);
    2617           1 :         oGeomFieldDefn2 = oGeomFieldDefn;
    2618           1 :         EXPECT_TRUE(oGeomFieldDefn2.IsSame(&oGeomFieldDefn));
    2619             :     }
    2620             : 
    2621             :     {
    2622           2 :         OGRSpatialReference oSRS;
    2623           1 :         oSRS.SetFromUserInput("WGS84");
    2624           1 :         EXPECT_EQ(oSRS.GetReferenceCount(), 1);
    2625           2 :         OGRGeomFieldDefn oGeomFieldDefn("field1", wkbPoint);
    2626           1 :         oGeomFieldDefn.SetSpatialRef(&oSRS);
    2627           1 :         EXPECT_EQ(oSRS.GetReferenceCount(), 2);
    2628           2 :         OGRGeomFieldDefn oGeomFieldDefn2("field2", wkbLineString);
    2629           1 :         oGeomFieldDefn2 = oGeomFieldDefn;
    2630           1 :         EXPECT_EQ(oSRS.GetReferenceCount(), 3);
    2631           1 :         EXPECT_TRUE(oGeomFieldDefn2.IsSame(&oGeomFieldDefn));
    2632             : 
    2633             :         // oGeomFieldDefn2 already points to oSRS
    2634           1 :         oGeomFieldDefn2 = oGeomFieldDefn;
    2635           1 :         EXPECT_EQ(oSRS.GetReferenceCount(), 3);
    2636           1 :         EXPECT_TRUE(oGeomFieldDefn2.IsSame(&oGeomFieldDefn));
    2637             :     }
    2638           1 : }
    2639             : 
    2640             : // Test GDALDataset QueryLoggerFunc callback
    2641           4 : TEST_F(test_ogr, GDALDatasetSetQueryLoggerFunc)
    2642             : {
    2643           1 :     if (GDALGetDriverByName("GPKG") == nullptr)
    2644             :     {
    2645           0 :         GTEST_SKIP() << "GPKG driver missing";
    2646             :     }
    2647             : 
    2648           1 :     auto tmpGPKG{testing::TempDir() + "/poly-1-feature.gpkg"};
    2649             :     {
    2650           2 :         std::string srcfilename(data_ + SEP + "poly-1-feature.gpkg");
    2651           2 :         std::ifstream src(srcfilename, std::ios::binary);
    2652           2 :         std::ofstream dst(tmpGPKG, std::ios::binary);
    2653           1 :         dst << src.rdbuf();
    2654             :     }
    2655             : 
    2656             :     struct QueryLogEntry
    2657             :     {
    2658             :         std::string sql;
    2659             :         std::string error;
    2660             :         int64_t numRecords;
    2661             :         int64_t executionTimeMilliseconds;
    2662             :     };
    2663             : 
    2664             :     // Note: this must be constructed before poDS or the order
    2665             :     //       of destruction will make the callback call the already
    2666             :     //       destructed vector
    2667           1 :     std::vector<QueryLogEntry> queryLog;
    2668             : 
    2669             :     auto poDS = std::unique_ptr<GDALDataset>(
    2670           1 :         GDALDataset::Open(tmpGPKG.c_str(), GDAL_OF_VECTOR | GDAL_OF_UPDATE));
    2671           1 :     ASSERT_TRUE(poDS);
    2672           1 :     auto hDS = GDALDataset::ToHandle(poDS.get());
    2673           1 :     ASSERT_TRUE(hDS);
    2674             : 
    2675           1 :     const bool retVal = GDALDatasetSetQueryLoggerFunc(
    2676             :         hDS,
    2677          18 :         [](const char *pszSQL, const char *pszError, int64_t lNumRecords,
    2678             :            int64_t lExecutionTimeMilliseconds, void *pQueryLoggerArg)
    2679             :         {
    2680          18 :             std::vector<QueryLogEntry> *queryLogLocal{
    2681             :                 reinterpret_cast<std::vector<QueryLogEntry> *>(
    2682             :                     pQueryLoggerArg)};
    2683          36 :             QueryLogEntry entryLocal;
    2684          18 :             if (pszSQL)
    2685             :             {
    2686          18 :                 entryLocal.sql = pszSQL;
    2687             :             }
    2688          18 :             entryLocal.numRecords = lNumRecords;
    2689          18 :             entryLocal.executionTimeMilliseconds = lExecutionTimeMilliseconds;
    2690          18 :             if (pszError)
    2691             :             {
    2692           1 :                 entryLocal.error = pszError;
    2693             :             }
    2694          18 :             queryLogLocal->push_back(std::move(entryLocal));
    2695          18 :         },
    2696           1 :         &queryLog);
    2697             : 
    2698           1 :     ASSERT_TRUE(retVal);
    2699           1 :     auto hLayer{GDALDatasetGetLayer(hDS, 0)};
    2700           1 :     ASSERT_TRUE(hLayer);
    2701           1 :     ASSERT_STREQ(OGR_L_GetName(hLayer), "poly");
    2702             :     auto poFeature = std::unique_ptr<OGRFeature>(
    2703           1 :         OGRFeature::FromHandle(OGR_L_GetNextFeature(hLayer)));
    2704           1 :     auto hFeature = OGRFeature::ToHandle(poFeature.get());
    2705           1 :     ASSERT_TRUE(hFeature);
    2706           1 :     ASSERT_GT(queryLog.size(), 1U);
    2707             : 
    2708           1 :     QueryLogEntry entry{queryLog.back()};
    2709           1 :     ASSERT_EQ(entry.sql.find("SELECT", 0), 0);
    2710           1 :     ASSERT_TRUE(entry.executionTimeMilliseconds >= 0);
    2711           1 :     ASSERT_EQ(entry.numRecords, -1);
    2712           1 :     ASSERT_TRUE(entry.error.empty());
    2713             : 
    2714             :     // Test erroneous query
    2715           1 :     OGRLayerH queryResultLayerH{GDALDatasetExecuteSQL(
    2716             :         hDS, "SELECT * FROM not_existing_table", nullptr, nullptr)};
    2717           1 :     GDALDatasetReleaseResultSet(hDS, queryResultLayerH);
    2718           1 :     ASSERT_FALSE(queryResultLayerH);
    2719             : 
    2720           1 :     entry = queryLog.back();
    2721           1 :     ASSERT_EQ(entry.sql.find("SELECT * FROM not_existing_table", 0), 0);
    2722           1 :     ASSERT_EQ(entry.executionTimeMilliseconds, -1);
    2723           1 :     ASSERT_EQ(entry.numRecords, -1);
    2724           1 :     ASSERT_FALSE(entry.error.empty());
    2725             : 
    2726             :     // Test prepared arg substitution
    2727           1 :     hFeature = OGR_F_Create(OGR_L_GetLayerDefn(hLayer));
    2728           1 :     poFeature.reset(OGRFeature::FromHandle(hFeature));
    2729           1 :     OGR_F_SetFieldInteger(hFeature, 1, 123);
    2730           1 :     OGRErr err = OGR_L_CreateFeature(hLayer, hFeature);
    2731           1 :     ASSERT_EQ(OGRERR_NONE, err);
    2732             : 
    2733             :     auto insertEntry = std::find_if(
    2734             :         queryLog.cbegin(), queryLog.cend(),
    2735          16 :         [](const QueryLogEntry &e)
    2736          17 :         { return e.sql.find(R"sql(INSERT INTO "poly")sql", 0) == 0; });
    2737             : 
    2738           1 :     ASSERT_TRUE(insertEntry != queryLog.end());
    2739           1 :     ASSERT_EQ(
    2740             :         insertEntry->sql.find(
    2741             :             R"sql(INSERT INTO "poly" ( "geom", "AREA", "EAS_ID", "PRFEDEA") VALUES (NULL, NULL, 123, NULL))sql",
    2742             :             0),
    2743             :         0);
    2744             : }
    2745             : 
    2746           4 : TEST_F(test_ogr, OGRParseDateTimeYYYYMMDDTHHMMZ)
    2747             : {
    2748             :     {
    2749           1 :         char szInput[] = "2023-07-11T17:27Z";
    2750             :         OGRField sField;
    2751           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMZ(szInput, &sField), true);
    2752           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2753           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2754           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2755           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2756           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2757           1 :         EXPECT_EQ(sField.Date.Second, 0.0f);
    2758           1 :         EXPECT_EQ(sField.Date.TZFlag, 100);
    2759             :     }
    2760             :     {
    2761           1 :         char szInput[] = "2023-07-11T17:27";
    2762             :         OGRField sField;
    2763           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMZ(szInput, &sField), true);
    2764           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2765           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2766           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2767           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2768           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2769           1 :         EXPECT_EQ(sField.Date.Second, 0.0f);
    2770           1 :         EXPECT_EQ(sField.Date.TZFlag, 0);
    2771             :     }
    2772             :     {
    2773             :         // Invalid
    2774           1 :         char szInput[] = "2023-07-11T17:2";
    2775             :         OGRField sField;
    2776           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMZ(szInput, &sField), false);
    2777             :     }
    2778             :     {
    2779             :         // Invalid
    2780           1 :         char szInput[] = "2023-07-11T17:99";
    2781             :         OGRField sField;
    2782           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMZ(szInput, &sField), false);
    2783             :     }
    2784           1 : }
    2785             : 
    2786           4 : TEST_F(test_ogr, OGRParseDateTimeYYYYMMDDTHHMMSSZ)
    2787             : {
    2788             :     {
    2789           1 :         char szInput[] = "2023-07-11T17:27:34Z";
    2790             :         OGRField sField;
    2791           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSZ(szInput, &sField), true);
    2792           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2793           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2794           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2795           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2796           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2797           1 :         EXPECT_EQ(sField.Date.Second, 34.0f);
    2798           1 :         EXPECT_EQ(sField.Date.TZFlag, 100);
    2799             :     }
    2800             :     {
    2801           1 :         char szInput[] = "2023-07-11T17:27:34";
    2802             :         OGRField sField;
    2803           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSZ(szInput, &sField), true);
    2804           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2805           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2806           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2807           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2808           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2809           1 :         EXPECT_EQ(sField.Date.Second, 34.0f);
    2810           1 :         EXPECT_EQ(sField.Date.TZFlag, 0);
    2811             :     }
    2812             :     {
    2813             :         // Invalid
    2814           1 :         char szInput[] = "2023-07-11T17:27:3";
    2815             :         OGRField sField;
    2816           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSZ(szInput, &sField), false);
    2817             :     }
    2818             :     {
    2819             :         // Invalid
    2820           1 :         char szInput[] = "2023-07-11T17:27:99";
    2821             :         OGRField sField;
    2822           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSZ(szInput, &sField), false);
    2823             :     }
    2824           1 : }
    2825             : 
    2826           4 : TEST_F(test_ogr, OGRParseDateTimeYYYYMMDDTHHMMSSsssZ)
    2827             : {
    2828             :     {
    2829           1 :         char szInput[] = "2023-07-11T17:27:34.123Z";
    2830             :         OGRField sField;
    2831           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(szInput, &sField), true);
    2832           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2833           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2834           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2835           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2836           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2837           1 :         EXPECT_EQ(sField.Date.Second, 34.123f);
    2838           1 :         EXPECT_EQ(sField.Date.TZFlag, 100);
    2839             :     }
    2840             :     {
    2841           1 :         char szInput[] = "2023-07-11T17:27:34.123";
    2842             :         OGRField sField;
    2843           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(szInput, &sField), true);
    2844           1 :         EXPECT_EQ(sField.Date.Year, 2023);
    2845           1 :         EXPECT_EQ(sField.Date.Month, 7);
    2846           1 :         EXPECT_EQ(sField.Date.Day, 11);
    2847           1 :         EXPECT_EQ(sField.Date.Hour, 17);
    2848           1 :         EXPECT_EQ(sField.Date.Minute, 27);
    2849           1 :         EXPECT_EQ(sField.Date.Second, 34.123f);
    2850           1 :         EXPECT_EQ(sField.Date.TZFlag, 0);
    2851             :     }
    2852             :     {
    2853             :         // Invalid
    2854           1 :         char szInput[] = "2023-07-11T17:27:34.12";
    2855             :         OGRField sField;
    2856           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(szInput, &sField), false);
    2857             :     }
    2858             :     {
    2859             :         // Invalid
    2860           1 :         char szInput[] = "2023-07-11T17:27:99.123";
    2861             :         OGRField sField;
    2862           1 :         EXPECT_EQ(OGRParseDateTimeYYYYMMDDTHHMMSSsssZ(szInput, &sField), false);
    2863             :     }
    2864           1 : }
    2865             : 
    2866           4 : TEST_F(test_ogr, OGRGetISO8601DateTime)
    2867             : {
    2868             :     OGRField sField;
    2869           1 :     sField.Date.Year = 2023;
    2870           1 :     sField.Date.Month = 7;
    2871           1 :     sField.Date.Day = 11;
    2872           1 :     sField.Date.Hour = 17;
    2873           1 :     sField.Date.Minute = 27;
    2874           1 :     sField.Date.Second = 34.567f;
    2875           1 :     sField.Date.TZFlag = 100;
    2876             :     {
    2877             :         char szResult[OGR_SIZEOF_ISO8601_DATETIME_BUFFER];
    2878             :         OGRISO8601Format sFormat;
    2879           1 :         sFormat.ePrecision = OGRISO8601Precision::AUTO;
    2880           1 :         OGRGetISO8601DateTime(&sField, sFormat, szResult);
    2881           1 :         EXPECT_STREQ(szResult, "2023-07-11T17:27:34.567Z");
    2882             :     }
    2883             :     {
    2884             :         char szResult[OGR_SIZEOF_ISO8601_DATETIME_BUFFER];
    2885             :         OGRISO8601Format sFormat;
    2886           1 :         sFormat.ePrecision = OGRISO8601Precision::MILLISECOND;
    2887           1 :         OGRGetISO8601DateTime(&sField, sFormat, szResult);
    2888           1 :         EXPECT_STREQ(szResult, "2023-07-11T17:27:34.567Z");
    2889             :     }
    2890             :     {
    2891             :         char szResult[OGR_SIZEOF_ISO8601_DATETIME_BUFFER];
    2892             :         OGRISO8601Format sFormat;
    2893           1 :         sFormat.ePrecision = OGRISO8601Precision::SECOND;
    2894           1 :         OGRGetISO8601DateTime(&sField, sFormat, szResult);
    2895           1 :         EXPECT_STREQ(szResult, "2023-07-11T17:27:35Z");
    2896             :     }
    2897             :     {
    2898             :         char szResult[OGR_SIZEOF_ISO8601_DATETIME_BUFFER];
    2899             :         OGRISO8601Format sFormat;
    2900           1 :         sFormat.ePrecision = OGRISO8601Precision::MINUTE;
    2901           1 :         OGRGetISO8601DateTime(&sField, sFormat, szResult);
    2902           1 :         EXPECT_STREQ(szResult, "2023-07-11T17:27Z");
    2903             :     }
    2904           1 :     sField.Date.Second = 34.0f;
    2905             :     {
    2906             :         char szResult[OGR_SIZEOF_ISO8601_DATETIME_BUFFER];
    2907             :         OGRISO8601Format sFormat;
    2908           1 :         sFormat.ePrecision = OGRISO8601Precision::AUTO;
    2909           1 :         OGRGetISO8601DateTime(&sField, sFormat, szResult);
    2910           1 :         EXPECT_STREQ(szResult, "2023-07-11T17:27:34Z");
    2911             :     }
    2912           1 : }
    2913             : 
    2914             : // Test calling importFromWkb() multiple times on the same geometry object
    2915           4 : TEST_F(test_ogr, importFromWkbReuse)
    2916             : {
    2917             :     {
    2918           2 :         OGRPoint oPoint;
    2919             :         {
    2920           1 :             size_t nBytesConsumed = 0;
    2921           1 :             EXPECT_EQ(oPoint.importFromWkb(
    2922             :                           reinterpret_cast<const GByte *>(
    2923             :                               "\x01\x01\x00\x00\x00"                // Point
    2924             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    2925             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    2926             :                           21, wkbVariantIso, nBytesConsumed),
    2927             :                       OGRERR_NONE);
    2928           1 :             EXPECT_EQ(nBytesConsumed, 21);
    2929           1 :             EXPECT_EQ(oPoint.getX(), 1.0);
    2930           1 :             EXPECT_EQ(oPoint.getY(), 2.0);
    2931             :         }
    2932             :         {
    2933           1 :             size_t nBytesConsumed = 0;
    2934           1 :             EXPECT_EQ(oPoint.importFromWkb(
    2935             :                           reinterpret_cast<const GByte *>(
    2936             :                               "\x01\x01\x00\x00\x00"              // Point
    2937             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"  // 2.0
    2938             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"  // 1.0
    2939             :                               ),
    2940             :                           21, wkbVariantIso, nBytesConsumed),
    2941             :                       OGRERR_NONE);
    2942           1 :             EXPECT_EQ(nBytesConsumed, 21);
    2943           1 :             EXPECT_EQ(oPoint.getX(), 2.0);
    2944           1 :             EXPECT_EQ(oPoint.getY(), 1.0);
    2945             :         }
    2946             :     }
    2947             : 
    2948             :     {
    2949           1 :         OGRLineString oLS;
    2950             :         {
    2951           1 :             size_t nBytesConsumed = 0;
    2952           1 :             EXPECT_EQ(oLS.importFromWkb(
    2953             :                           reinterpret_cast<const GByte *>(
    2954             :                               "\x01\x02\x00\x00\x00"              // LineString
    2955             :                               "\x01\x00\x00\x00"                  // 1 point
    2956             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"  // 1.0
    2957             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    2958             :                           25, wkbVariantIso, nBytesConsumed),
    2959             :                       OGRERR_NONE);
    2960           1 :             EXPECT_EQ(nBytesConsumed, 25);
    2961           1 :             ASSERT_EQ(oLS.getNumPoints(), 1);
    2962           1 :             EXPECT_EQ(oLS.getX(0), 1.0);
    2963           1 :             EXPECT_EQ(oLS.getY(0), 2.0);
    2964             :         }
    2965             :         {
    2966           1 :             size_t nBytesConsumed = 0;
    2967           1 :             EXPECT_EQ(oLS.importFromWkb(
    2968             :                           reinterpret_cast<const GByte *>(
    2969             :                               "\x01\x02\x00\x00\x00"              // LineString
    2970             :                               "\x02\x00\x00\x00"                  // 2 points
    2971             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"  // 1.0
    2972             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"  // 2.0
    2973             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"  // 2.0
    2974             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    2975             :                           41, wkbVariantIso, nBytesConsumed),
    2976             :                       OGRERR_NONE);
    2977           1 :             EXPECT_EQ(nBytesConsumed, 41);
    2978           1 :             ASSERT_EQ(oLS.getNumPoints(), 2);
    2979           1 :             EXPECT_EQ(oLS.getX(0), 1.0);
    2980           1 :             EXPECT_EQ(oLS.getY(0), 2.0);
    2981           1 :             EXPECT_EQ(oLS.getX(1), 2.0);
    2982           1 :             EXPECT_EQ(oLS.getY(1), 1.0);
    2983             :         }
    2984             :         {
    2985           1 :             size_t nBytesConsumed = 0;
    2986           1 :             EXPECT_EQ(oLS.importFromWkb(
    2987             :                           reinterpret_cast<const GByte *>(
    2988             :                               "\x01\x02\x00\x00\x00"              // LineString
    2989             :                               "\x01\x00\x00\x00"                  // 1 point
    2990             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"  // 2.0
    2991             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    2992             :                           25, wkbVariantIso, nBytesConsumed),
    2993             :                       OGRERR_NONE);
    2994           1 :             EXPECT_EQ(nBytesConsumed, 25);
    2995           1 :             ASSERT_EQ(oLS.getNumPoints(), 1);
    2996           1 :             EXPECT_EQ(oLS.getX(0), 2.0);
    2997           1 :             EXPECT_EQ(oLS.getY(0), 1.0);
    2998             :         }
    2999             :     }
    3000             : 
    3001             :     {
    3002           1 :         OGRPolygon oPoly;
    3003             :         {
    3004           1 :             size_t nBytesConsumed = 0;
    3005           1 :             EXPECT_EQ(oPoly.importFromWkb(
    3006             :                           reinterpret_cast<const GByte *>(
    3007             :                               "\x01\x03\x00\x00\x00"                // Polygon
    3008             :                               "\x01\x00\x00\x00"                    // 1 ring
    3009             :                               "\x01\x00\x00\x00"                    // 1 point
    3010             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3011             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3012             :                           29, wkbVariantIso, nBytesConsumed),
    3013             :                       OGRERR_NONE);
    3014           1 :             EXPECT_EQ(nBytesConsumed, 29);
    3015           1 :             ASSERT_TRUE(oPoly.getExteriorRing() != nullptr);
    3016           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3017           1 :             auto poLS = oPoly.getExteriorRing();
    3018           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3019           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3020           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3021             :         }
    3022             :         {
    3023           1 :             size_t nBytesConsumed = 0;
    3024           1 :             EXPECT_EQ(oPoly.importFromWkb(
    3025             :                           reinterpret_cast<const GByte *>(
    3026             :                               "\x01\x03\x00\x00\x00"                // Polygon
    3027             :                               "\x01\x00\x00\x00"                    // 1 ring
    3028             :                               "\x01\x00\x00\x00"                    // 1 point
    3029             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"    // 2.0
    3030             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    3031             :                           29, wkbVariantIso, nBytesConsumed),
    3032             :                       OGRERR_NONE);
    3033           1 :             EXPECT_EQ(nBytesConsumed, 29);
    3034           1 :             ASSERT_TRUE(oPoly.getExteriorRing() != nullptr);
    3035           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3036           1 :             auto poLS = oPoly.getExteriorRing();
    3037           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3038           1 :             EXPECT_EQ(poLS->getX(0), 2.0);
    3039           1 :             EXPECT_EQ(poLS->getY(0), 1.0);
    3040             :         }
    3041             :         {
    3042           1 :             size_t nBytesConsumed = 0;
    3043           1 :             EXPECT_EQ(oPoly.importFromWkb(reinterpret_cast<const GByte *>(
    3044             :                                               "\x01\x03\x00\x00\x00"  // Polygon
    3045             :                                               "\x00\x00\x00\x00"),    // 0 ring
    3046             :                                           9, wkbVariantIso, nBytesConsumed),
    3047             :                       OGRERR_NONE);
    3048           1 :             EXPECT_EQ(nBytesConsumed, 9);
    3049           1 :             ASSERT_TRUE(oPoly.getExteriorRing() == nullptr);
    3050           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3051             :         }
    3052             :         {
    3053           1 :             size_t nBytesConsumed = 0;
    3054           1 :             EXPECT_EQ(oPoly.importFromWkb(
    3055             :                           reinterpret_cast<const GByte *>(
    3056             :                               "\x01\x03\x00\x00\x00"                // Polygon
    3057             :                               "\x01\x00\x00\x00"                    // 1 ring
    3058             :                               "\x01\x00\x00\x00"                    // 1 point
    3059             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3060             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3061             :                           29, wkbVariantIso, nBytesConsumed),
    3062             :                       OGRERR_NONE);
    3063           1 :             EXPECT_EQ(nBytesConsumed, 29);
    3064           1 :             ASSERT_TRUE(oPoly.getExteriorRing() != nullptr);
    3065           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3066           1 :             auto poLS = oPoly.getExteriorRing();
    3067           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3068           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3069           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3070             :         }
    3071             :         {
    3072           1 :             size_t nBytesConsumed = 0;
    3073           1 :             EXPECT_EQ(oPoly.importFromWkb(
    3074             :                           reinterpret_cast<const GByte *>(
    3075             :                               "\x01\x03\x00\x00\x00"                // Polygon
    3076             :                               "\x01\x00\x00\x00"                    // 1 ring
    3077             :                               "\x01\x00\x00\x00"                    // 1 point
    3078             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"    // 2.0
    3079             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    3080             :                           static_cast<size_t>(-1), wkbVariantIso,
    3081             :                           nBytesConsumed),
    3082             :                       OGRERR_NONE);
    3083           1 :             EXPECT_EQ(nBytesConsumed, 29);
    3084           1 :             ASSERT_TRUE(oPoly.getExteriorRing() != nullptr);
    3085           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3086           1 :             auto poLS = oPoly.getExteriorRing();
    3087           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3088           1 :             EXPECT_EQ(poLS->getX(0), 2.0);
    3089           1 :             EXPECT_EQ(poLS->getY(0), 1.0);
    3090             :         }
    3091             :         {
    3092           1 :             size_t nBytesConsumed = 0;
    3093             :             // Truncated WKB
    3094           1 :             EXPECT_NE(oPoly.importFromWkb(reinterpret_cast<const GByte *>(
    3095             :                                               "\x01\x03\x00\x00\x00"  // Polygon
    3096             :                                               "\x01\x00\x00\x00"      // 1 ring
    3097             :                                               "\x01\x00\x00\x00"),    // 1 point
    3098             :                                           13, wkbVariantIso, nBytesConsumed),
    3099             :                       OGRERR_NONE);
    3100           1 :             ASSERT_TRUE(oPoly.getExteriorRing() == nullptr);
    3101           1 :             ASSERT_EQ(oPoly.getNumInteriorRings(), 0);
    3102             :         }
    3103             :     }
    3104             : 
    3105             :     {
    3106           1 :         OGRMultiLineString oMLS;
    3107             :         {
    3108           1 :             size_t nBytesConsumed = 0;
    3109           1 :             EXPECT_EQ(oMLS.importFromWkb(
    3110             :                           reinterpret_cast<const GByte *>(
    3111             :                               "\x01\x05\x00\x00\x00"  // MultiLineString
    3112             :                               "\x01\x00\x00\x00"      // 1-part
    3113             :                               "\x01\x02\x00\x00\x00"  // LineString
    3114             :                               "\x01\x00\x00\x00"      // 1 point
    3115             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3116             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3117             :                           34, wkbVariantIso, nBytesConsumed),
    3118             :                       OGRERR_NONE);
    3119           1 :             EXPECT_EQ(nBytesConsumed, 34);
    3120           1 :             ASSERT_EQ(oMLS.getNumGeometries(), 1);
    3121           1 :             auto poLS = oMLS.getGeometryRef(0);
    3122           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3123           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3124           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3125             :         }
    3126             :         {
    3127           1 :             size_t nBytesConsumed = 0;
    3128           1 :             EXPECT_EQ(oMLS.importFromWkb(
    3129             :                           reinterpret_cast<const GByte *>(
    3130             :                               "\x01\x05\x00\x00\x00"  // MultiLineString
    3131             :                               "\x01\x00\x00\x00"      // 1-part
    3132             :                               "\x01\x02\x00\x00\x00"  // LineString
    3133             :                               "\x01\x00\x00\x00"      // 1 point
    3134             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"    // 2.0
    3135             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    3136             :                           34, wkbVariantIso, nBytesConsumed),
    3137             :                       OGRERR_NONE);
    3138           1 :             EXPECT_EQ(nBytesConsumed, 34);
    3139           1 :             ASSERT_EQ(oMLS.getNumGeometries(), 1);
    3140           1 :             auto poLS = oMLS.getGeometryRef(0);
    3141           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3142           1 :             EXPECT_EQ(poLS->getX(0), 2.0);
    3143           1 :             EXPECT_EQ(poLS->getY(0), 1.0);
    3144             :         }
    3145             :         {
    3146           1 :             size_t nBytesConsumed = 0;
    3147           1 :             EXPECT_EQ(oMLS.importFromWkb(
    3148             :                           reinterpret_cast<const GByte *>(
    3149             :                               "\x01\x05\x00\x00\x00"  // MultiLineString
    3150             :                               "\x01\x00\x00\x00"      // 1-part
    3151             :                               "\x01\x02\x00\x00\x00"  // LineString
    3152             :                               "\x01\x00\x00\x00"      // 1 point
    3153             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3154             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3155             :                           static_cast<size_t>(-1), wkbVariantIso,
    3156             :                           nBytesConsumed),
    3157             :                       OGRERR_NONE);
    3158           1 :             EXPECT_EQ(nBytesConsumed, 34);
    3159           1 :             ASSERT_EQ(oMLS.getNumGeometries(), 1);
    3160           1 :             auto poLS = oMLS.getGeometryRef(0);
    3161           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3162           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3163           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3164             :         }
    3165             :         {
    3166           1 :             size_t nBytesConsumed = 0;
    3167             :             // Truncated WKB
    3168           1 :             EXPECT_NE(oMLS.importFromWkb(
    3169             :                           reinterpret_cast<const GByte *>(
    3170             :                               "\x01\x05\x00\x00\x00"  // MultiLineString
    3171             :                               "\x01\x00\x00\x00"      // 1-part
    3172             :                               "\x01\x02\x00\x00\x00"  // LineString
    3173             :                               "\x01\x00\x00\x00"      // 1 point
    3174             :                               ),
    3175             :                           18, wkbVariantIso, nBytesConsumed),
    3176             :                       OGRERR_NONE);
    3177           1 :             ASSERT_EQ(oMLS.getNumGeometries(), 0);
    3178             :         }
    3179             :     }
    3180             : 
    3181             :     {
    3182           1 :         OGRMultiPolygon oMP;
    3183             :         {
    3184           1 :             size_t nBytesConsumed = 0;
    3185           1 :             EXPECT_EQ(oMP.importFromWkb(
    3186             :                           reinterpret_cast<const GByte *>(
    3187             :                               "\x01\x06\x00\x00\x00"  // MultiPolygon
    3188             :                               "\x01\x00\x00\x00"      // 1-part
    3189             :                               "\x01\x03\x00\x00\x00"  // Polygon
    3190             :                               "\x01\x00\x00\x00"      // 1 ring
    3191             :                               "\x01\x00\x00\x00"      // 1 point
    3192             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3193             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3194             :                           38, wkbVariantIso, nBytesConsumed),
    3195             :                       OGRERR_NONE);
    3196           1 :             EXPECT_EQ(nBytesConsumed, 38);
    3197           1 :             ASSERT_EQ(oMP.getNumGeometries(), 1);
    3198           1 :             auto poPoly = oMP.getGeometryRef(0);
    3199           1 :             ASSERT_TRUE(poPoly->getExteriorRing() != nullptr);
    3200           1 :             ASSERT_EQ(poPoly->getNumInteriorRings(), 0);
    3201           1 :             auto poLS = poPoly->getExteriorRing();
    3202           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3203           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3204           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3205             :         }
    3206             :         {
    3207           1 :             size_t nBytesConsumed = 0;
    3208           1 :             EXPECT_EQ(oMP.importFromWkb(
    3209             :                           reinterpret_cast<const GByte *>(
    3210             :                               "\x01\x06\x00\x00\x00"  // MultiPolygon
    3211             :                               "\x01\x00\x00\x00"      // 1-part
    3212             :                               "\x01\x03\x00\x00\x00"  // Polygon
    3213             :                               "\x01\x00\x00\x00"      // 1 ring
    3214             :                               "\x01\x00\x00\x00"      // 1 point
    3215             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"    // 2.0
    3216             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"),  // 1.0
    3217             :                           38, wkbVariantIso, nBytesConsumed),
    3218             :                       OGRERR_NONE);
    3219           1 :             EXPECT_EQ(nBytesConsumed, 38);
    3220           1 :             ASSERT_EQ(oMP.getNumGeometries(), 1);
    3221           1 :             auto poPoly = oMP.getGeometryRef(0);
    3222           1 :             ASSERT_TRUE(poPoly->getExteriorRing() != nullptr);
    3223           1 :             ASSERT_EQ(poPoly->getNumInteriorRings(), 0);
    3224           1 :             auto poLS = poPoly->getExteriorRing();
    3225           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3226           1 :             EXPECT_EQ(poLS->getX(0), 2.0);
    3227           1 :             EXPECT_EQ(poLS->getY(0), 1.0);
    3228             :         }
    3229             :         {
    3230           1 :             size_t nBytesConsumed = 0;
    3231           1 :             EXPECT_EQ(oMP.importFromWkb(
    3232             :                           reinterpret_cast<const GByte *>(
    3233             :                               "\x01\x06\x00\x00\x00"  // MultiPolygon
    3234             :                               "\x01\x00\x00\x00"      // 1-part
    3235             :                               "\x01\x03\x00\x00\x00"  // Polygon
    3236             :                               "\x01\x00\x00\x00"      // 1 ring
    3237             :                               "\x01\x00\x00\x00"      // 1 point
    3238             :                               "\x00\x00\x00\x00\x00\x00\xf0\x3f"    // 1.0
    3239             :                               "\x00\x00\x00\x00\x00\x00\x00\x40"),  // 2.0
    3240             :                           static_cast<size_t>(-1), wkbVariantIso,
    3241             :                           nBytesConsumed),
    3242             :                       OGRERR_NONE);
    3243           1 :             EXPECT_EQ(nBytesConsumed, 38);
    3244           1 :             ASSERT_EQ(oMP.getNumGeometries(), 1);
    3245           1 :             auto poPoly = oMP.getGeometryRef(0);
    3246           1 :             ASSERT_TRUE(poPoly->getExteriorRing() != nullptr);
    3247           1 :             ASSERT_EQ(poPoly->getNumInteriorRings(), 0);
    3248           1 :             auto poLS = poPoly->getExteriorRing();
    3249           1 :             ASSERT_EQ(poLS->getNumPoints(), 1);
    3250           1 :             EXPECT_EQ(poLS->getX(0), 1.0);
    3251           1 :             EXPECT_EQ(poLS->getY(0), 2.0);
    3252             :         }
    3253             :         {
    3254           1 :             size_t nBytesConsumed = 0;
    3255             :             // Truncated WKB
    3256           1 :             EXPECT_NE(
    3257             :                 oMP.importFromWkb(reinterpret_cast<const GByte *>(
    3258             :                                       "\x01\x06\x00\x00\x00"  // MultiPolygon
    3259             :                                       "\x01\x00\x00\x00"      // 1-part
    3260             :                                       "\x01\x03\x00\x00\x00"  // Polygon
    3261             :                                       "\x01\x00\x00\x00"      // 1 ring
    3262             :                                       "\x01\x00\x00\x00"      // 1 point
    3263             :                                       ),
    3264             :                                   22, wkbVariantIso, nBytesConsumed),
    3265             :                 OGRERR_NONE);
    3266           1 :             ASSERT_EQ(oMP.getNumGeometries(), 0);
    3267             :         }
    3268             :     }
    3269             : }
    3270             : 
    3271             : // Test sealing functionality on OGRFieldDefn
    3272           4 : TEST_F(test_ogr, OGRFieldDefn_sealing)
    3273             : {
    3274           2 :     OGRFieldDefn oFieldDefn("test", OFTString);
    3275           1 :     oFieldDefn.Seal();
    3276             : 
    3277             :     {
    3278           1 :         CPLErrorReset();
    3279           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3280           1 :         oFieldDefn.SetName("new_name");
    3281           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3282             :     }
    3283             : 
    3284             :     {
    3285           1 :         CPLErrorReset();
    3286           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3287           1 :         oFieldDefn.SetType(OFTInteger);
    3288           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3289             :     }
    3290             : 
    3291             :     {
    3292           1 :         CPLErrorReset();
    3293           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3294           1 :         oFieldDefn.SetSubType(OFSTJSON);
    3295           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3296             :     }
    3297             : 
    3298             :     {
    3299           1 :         CPLErrorReset();
    3300           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3301           1 :         oFieldDefn.SetWidth(1);
    3302           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3303             :     }
    3304             : 
    3305             :     {
    3306           1 :         CPLErrorReset();
    3307           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3308           1 :         oFieldDefn.SetPrecision(1);
    3309           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3310             :     }
    3311             : 
    3312             :     {
    3313           1 :         CPLErrorReset();
    3314           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3315           1 :         oFieldDefn.SetDefault("");
    3316           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3317             :     }
    3318             : 
    3319             :     {
    3320           1 :         CPLErrorReset();
    3321           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3322           1 :         oFieldDefn.SetUnique(true);
    3323           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3324             :     }
    3325             : 
    3326             :     {
    3327           1 :         CPLErrorReset();
    3328           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3329           1 :         oFieldDefn.SetNullable(false);
    3330           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3331             :     }
    3332             : 
    3333             :     {
    3334           1 :         CPLErrorReset();
    3335           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3336           1 :         oFieldDefn.SetComment("");
    3337           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3338             :     }
    3339             : 
    3340             :     {
    3341           1 :         CPLErrorReset();
    3342           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3343           1 :         oFieldDefn.SetAlternativeName("");
    3344           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3345             :     }
    3346             : 
    3347             :     {
    3348           1 :         CPLErrorReset();
    3349           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3350           1 :         oFieldDefn.SetDomainName("");
    3351           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3352             :     }
    3353             : 
    3354             :     {
    3355           1 :         CPLErrorReset();
    3356           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3357           1 :         oFieldDefn.SetTZFlag(0);
    3358           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3359             :     }
    3360             : 
    3361             :     {
    3362           2 :         auto oTemporaryUnsealer(oFieldDefn.GetTemporaryUnsealer());
    3363           1 :         CPLErrorReset();
    3364           1 :         oFieldDefn.SetName("new_name");
    3365           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") == nullptr);
    3366             :     }
    3367             : 
    3368             :     {
    3369           1 :         CPLErrorReset();
    3370           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3371           1 :         oFieldDefn.SetName("new_name");
    3372           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3373             :     }
    3374             : 
    3375             :     {
    3376           1 :         CPLErrorReset();
    3377           1 :         whileUnsealing(&oFieldDefn)->SetName("new_name");
    3378           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3379             :     }
    3380           1 : }
    3381             : 
    3382             : // Test sealing functionality on OGRGeomFieldDefn
    3383           4 : TEST_F(test_ogr, OGRGeomFieldDefn_sealing)
    3384             : {
    3385           2 :     OGRGeomFieldDefn oFieldDefn("test", wkbUnknown);
    3386             : 
    3387           1 :     oFieldDefn.Seal();
    3388             : 
    3389             :     {
    3390           1 :         CPLErrorReset();
    3391           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3392           1 :         oFieldDefn.SetName("new_name");
    3393           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3394             :     }
    3395             : 
    3396             :     {
    3397           1 :         CPLErrorReset();
    3398           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3399           1 :         oFieldDefn.SetType(wkbPoint);
    3400           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3401             :     }
    3402             : 
    3403             :     {
    3404           1 :         CPLErrorReset();
    3405           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3406           1 :         oFieldDefn.SetSpatialRef(nullptr);
    3407           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3408             :     }
    3409             : 
    3410             :     {
    3411           1 :         CPLErrorReset();
    3412           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3413           1 :         oFieldDefn.SetNullable(false);
    3414           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3415             :     }
    3416             : 
    3417             :     {
    3418           2 :         auto oTemporaryUnsealer(oFieldDefn.GetTemporaryUnsealer());
    3419           1 :         CPLErrorReset();
    3420           1 :         oFieldDefn.SetName("new_name");
    3421           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3422             :     }
    3423             : 
    3424             :     {
    3425           1 :         CPLErrorReset();
    3426           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3427           1 :         oFieldDefn.SetName("new_name");
    3428           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3429             :     }
    3430             : 
    3431             :     {
    3432           1 :         CPLErrorReset();
    3433           1 :         whileUnsealing(&oFieldDefn)->SetName("new_name");
    3434           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3435             :     }
    3436           1 : }
    3437             : 
    3438             : // Test sealing functionality on OGRFeatureDefn
    3439           4 : TEST_F(test_ogr, OGRFeatureDefn_sealing)
    3440             : {
    3441           2 :     OGRFeatureDefn oFDefn;
    3442           1 :     CPLErrorReset();
    3443             :     {
    3444           1 :         oFDefn.SetName("new_name");
    3445           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3446             :     }
    3447             :     {
    3448           2 :         OGRFieldDefn oFieldDefn("test", OFTString);
    3449           1 :         oFDefn.AddFieldDefn(&oFieldDefn);
    3450           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3451             :     }
    3452             :     {
    3453           2 :         OGRGeomFieldDefn oFieldDefn("test", wkbUnknown);
    3454           1 :         oFDefn.AddGeomFieldDefn(&oFieldDefn);
    3455           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3456             :     }
    3457             : 
    3458             :     {
    3459           1 :         CPLErrorReset();
    3460           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3461           1 :         oFDefn.Unseal(true);
    3462           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "unsealed") != nullptr);
    3463             : 
    3464           1 :         CPLErrorReset();
    3465           2 :         auto oTemporaryUnsealer1(oFDefn.GetTemporaryUnsealer(false));
    3466           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "unsealed") != nullptr);
    3467           1 :         CPLErrorReset();
    3468           2 :         auto oTemporaryUnsealer2(oFDefn.GetTemporaryUnsealer(false));
    3469           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3470             :     }
    3471             : 
    3472           1 :     oFDefn.Seal(true);
    3473             : 
    3474             :     {
    3475           1 :         CPLErrorReset();
    3476           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3477           1 :         oFDefn.Seal(true);
    3478           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3479             :     }
    3480             : 
    3481             :     {
    3482           1 :         CPLErrorReset();
    3483           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3484           1 :         oFDefn.SetName("new_name");
    3485           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3486             :     }
    3487             : 
    3488             :     {
    3489           1 :         CPLErrorReset();
    3490           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3491           2 :         OGRFieldDefn oFieldDefn("test2", OFTString);
    3492           1 :         oFDefn.AddFieldDefn(&oFieldDefn);
    3493           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3494             :     }
    3495             : 
    3496             :     {
    3497           1 :         CPLErrorReset();
    3498           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3499           1 :         oFDefn.DeleteFieldDefn(0);
    3500           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3501             :     }
    3502             : 
    3503             :     {
    3504           1 :         CPLErrorReset();
    3505           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3506           1 :         int map[] = {0};
    3507           1 :         oFDefn.ReorderFieldDefns(map);
    3508           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3509             :     }
    3510             : 
    3511             :     {
    3512           1 :         CPLErrorReset();
    3513           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3514           2 :         OGRGeomFieldDefn oFieldDefn("test2", wkbUnknown);
    3515           1 :         oFDefn.AddGeomFieldDefn(&oFieldDefn);
    3516           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3517             :     }
    3518             : 
    3519             :     {
    3520           1 :         CPLErrorReset();
    3521           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3522           1 :         oFDefn.DeleteGeomFieldDefn(0);
    3523           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3524             :     }
    3525             : 
    3526             :     {
    3527           2 :         auto oTemporaryUnsealer(oFDefn.GetTemporaryUnsealer(false));
    3528           1 :         CPLErrorReset();
    3529           1 :         oFDefn.SetName("new_name");
    3530           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3531             : 
    3532           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3533           1 :         CPLErrorReset();
    3534           1 :         oFDefn.GetFieldDefn(0)->SetName("new_name");
    3535           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3536             : 
    3537           1 :         CPLErrorReset();
    3538           1 :         oFDefn.GetGeomFieldDefn(0)->SetName("new_name");
    3539           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3540             :     }
    3541             : 
    3542             :     {
    3543             : 
    3544           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3545           1 :         CPLErrorReset();
    3546           1 :         oFDefn.GetFieldDefn(0)->SetName("new_name");
    3547           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3548             : 
    3549           1 :         CPLErrorReset();
    3550           1 :         oFDefn.GetGeomFieldDefn(0)->SetName("new_name");
    3551           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3552             :     }
    3553             : 
    3554             :     {
    3555           2 :         auto oTemporaryUnsealer(oFDefn.GetTemporaryUnsealer(true));
    3556           1 :         CPLErrorReset();
    3557           1 :         oFDefn.SetName("new_name");
    3558           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3559             : 
    3560           1 :         oFDefn.GetFieldDefn(0)->SetName("new_name");
    3561           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3562             : 
    3563           2 :         auto oTemporaryUnsealer2(oFDefn.GetTemporaryUnsealer(true));
    3564             : 
    3565           1 :         oFDefn.GetGeomFieldDefn(0)->SetName("new_name");
    3566           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3567             :     }
    3568             : 
    3569             :     {
    3570             : 
    3571           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    3572           1 :         CPLErrorReset();
    3573           1 :         oFDefn.GetFieldDefn(0)->SetName("new_name");
    3574           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3575             : 
    3576           1 :         CPLErrorReset();
    3577           1 :         oFDefn.GetGeomFieldDefn(0)->SetName("new_name");
    3578           1 :         EXPECT_TRUE(strstr(CPLGetLastErrorMsg(), "sealed") != nullptr);
    3579             :     }
    3580             : 
    3581             :     {
    3582           1 :         CPLErrorReset();
    3583           1 :         whileUnsealing(&oFDefn)->SetName("new_name");
    3584           1 :         EXPECT_EQ(CPLGetLastErrorType(), CE_None);
    3585             :     }
    3586           1 : }
    3587             : 
    3588             : // Test wkbExportOptions
    3589           4 : TEST_F(test_ogr, wkbExportOptions_default)
    3590             : {
    3591           1 :     OGRwkbExportOptions *psOptions = OGRwkbExportOptionsCreate();
    3592           1 :     ASSERT_TRUE(psOptions != nullptr);
    3593           2 :     OGRPoint p(1.23456789012345678, 2.23456789012345678, 3);
    3594           2 :     std::vector<GByte> abyWKB(p.WkbSize());
    3595           1 :     OGR_G_ExportToWkbEx(OGRGeometry::ToHandle(&p), &abyWKB[0], psOptions);
    3596           1 :     OGRwkbExportOptionsDestroy(psOptions);
    3597             : 
    3598           2 :     std::vector<GByte> abyRegularWKB(p.WkbSize());
    3599           1 :     OGR_G_ExportToWkb(OGRGeometry::ToHandle(&p), wkbNDR, &abyRegularWKB[0]);
    3600             : 
    3601           1 :     EXPECT_TRUE(abyWKB == abyRegularWKB);
    3602             : }
    3603             : 
    3604             : // Test wkbExportOptions
    3605           4 : TEST_F(test_ogr, wkbExportOptions)
    3606             : {
    3607           1 :     OGRwkbExportOptions *psOptions = OGRwkbExportOptionsCreate();
    3608           1 :     ASSERT_TRUE(psOptions != nullptr);
    3609           1 :     OGRwkbExportOptionsSetByteOrder(psOptions, wkbXDR);
    3610           1 :     OGRwkbExportOptionsSetVariant(psOptions, wkbVariantIso);
    3611             : 
    3612           1 :     auto hPrec = OGRGeomCoordinatePrecisionCreate();
    3613           1 :     OGRGeomCoordinatePrecisionSet(hPrec, 1e-1, 1e-2, 1e-4);
    3614           1 :     OGRwkbExportOptionsSetPrecision(psOptions, hPrec);
    3615           1 :     OGRGeomCoordinatePrecisionDestroy(hPrec);
    3616             : 
    3617             :     OGRPoint p(1.23456789012345678, -1.23456789012345678, 1.23456789012345678,
    3618           1 :                1.23456789012345678);
    3619           1 :     std::vector<GByte> abyWKB(p.WkbSize());
    3620           1 :     OGR_G_ExportToWkbEx(OGRGeometry::ToHandle(&p), &abyWKB[0], psOptions);
    3621           1 :     OGRwkbExportOptionsDestroy(psOptions);
    3622             : 
    3623             :     const std::vector<GByte> expectedWKB{
    3624             :         0x00, 0x00, 0x00, 0x0B, 0xB9, 0x3F, 0xF3, 0x80, 0x00, 0x00,
    3625             :         0x00, 0x00, 0x00, 0xBF, 0xF3, 0x80, 0x00, 0x00, 0x00, 0x00,
    3626             :         0x00, 0x3F, 0xF3, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F,
    3627           1 :         0xF3, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00};
    3628           1 :     EXPECT_TRUE(abyWKB == expectedWKB);
    3629             : 
    3630           1 :     OGRGeometry *poGeom = nullptr;
    3631           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3632           1 :     ASSERT_NE(poGeom, nullptr);
    3633           1 :     EXPECT_NEAR(poGeom->toPoint()->getX(), 1.2, 1e-1);
    3634           1 :     EXPECT_NEAR(poGeom->toPoint()->getY(), -1.2, 1e-1);
    3635           1 :     EXPECT_NEAR(poGeom->toPoint()->getZ(), 1.23, 1e-2);
    3636           1 :     EXPECT_NEAR(poGeom->toPoint()->getM(), 1.2346, 1e-4);
    3637           1 :     delete poGeom;
    3638             : }
    3639             : 
    3640             : // Test OGRGeometry::roundCoordinatesIEEE754()
    3641           4 : TEST_F(test_ogr, roundCoordinatesIEEE754)
    3642             : {
    3643           2 :     OGRLineString oLS;
    3644           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, -1.2345678901234, 0.012345);
    3645           1 :     oLS.addPoint(-1.2345678901234, 1.2345678901234, 1.2345678901234, -0.012345);
    3646           1 :     oLS.addPoint(std::numeric_limits<double>::infinity(),
    3647             :                  std::numeric_limits<double>::quiet_NaN());
    3648           1 :     OGRGeomCoordinateBinaryPrecision sBinaryPrecision;
    3649           2 :     OGRGeomCoordinatePrecision sPrecision;
    3650           1 :     sPrecision.dfXYResolution = 1e-10;
    3651           1 :     sPrecision.dfZResolution = 1e-3;
    3652           1 :     sPrecision.dfMResolution = 1e-5;
    3653           1 :     sBinaryPrecision.SetFrom(sPrecision);
    3654           2 :     OGRLineString oLSOri(oLS);
    3655           1 :     oLS.roundCoordinatesIEEE754(sBinaryPrecision);
    3656           1 :     EXPECT_NE(oLS.getX(0), oLSOri.getX(0));
    3657           1 :     EXPECT_NE(oLS.getY(0), oLSOri.getY(0));
    3658           1 :     EXPECT_NE(oLS.getZ(0), oLSOri.getZ(0));
    3659           1 :     EXPECT_NE(oLS.getM(0), oLSOri.getM(0));
    3660           1 :     EXPECT_NEAR(oLS.getX(0), oLSOri.getX(0), sPrecision.dfXYResolution);
    3661           1 :     EXPECT_NEAR(oLS.getY(0), oLSOri.getY(0), sPrecision.dfXYResolution);
    3662           1 :     EXPECT_NEAR(oLS.getZ(0), oLSOri.getZ(0), sPrecision.dfZResolution);
    3663           1 :     EXPECT_NEAR(oLS.getM(0), oLSOri.getM(0), sPrecision.dfMResolution);
    3664           1 :     EXPECT_NEAR(oLS.getX(1), oLSOri.getX(1), sPrecision.dfXYResolution);
    3665           1 :     EXPECT_NEAR(oLS.getY(1), oLSOri.getY(1), sPrecision.dfXYResolution);
    3666           1 :     EXPECT_NEAR(oLS.getZ(1), oLSOri.getZ(1), sPrecision.dfZResolution);
    3667           1 :     EXPECT_NEAR(oLS.getM(1), oLSOri.getM(1), sPrecision.dfMResolution);
    3668           1 :     EXPECT_EQ(oLS.getX(2), std::numeric_limits<double>::infinity());
    3669           1 :     EXPECT_TRUE(std::isnan(oLS.getY(2)));
    3670           1 : }
    3671             : 
    3672             : // Test discarding of bits in WKB export
    3673           4 : TEST_F(test_ogr, wkb_linestring_2d_xy_precision)
    3674             : {
    3675           2 :     OGRLineString oLS;
    3676           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234);
    3677           1 :     oLS.addPoint(-1.2345678901234, 1.2345678901234);
    3678           1 :     OGRwkbExportOptions sOptions;
    3679           2 :     OGRGeomCoordinatePrecision sPrecision;
    3680           1 :     sPrecision.dfXYResolution = 1e-10;
    3681           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3682           2 :     std::vector<GByte> abyWKB(oLS.WkbSize());
    3683           1 :     oLS.exportToWkb(&abyWKB[0], &sOptions);
    3684           3 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3685             :     {
    3686           2 :         EXPECT_EQ(abyWKB[5 + 4 + 0 + 8 * i], 0);
    3687             :     }
    3688           1 :     OGRGeometry *poGeom = nullptr;
    3689           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3690           1 :     EXPECT_NE(poGeom->toLineString()->getX(0), oLS.getX(0));
    3691           1 :     EXPECT_NE(poGeom->toLineString()->getY(0), oLS.getY(0));
    3692           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(0), oLS.getX(0),
    3693             :                 sPrecision.dfXYResolution);
    3694           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(0), oLS.getY(0),
    3695             :                 sPrecision.dfXYResolution);
    3696           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(1), oLS.getX(1),
    3697             :                 sPrecision.dfXYResolution);
    3698           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(1), oLS.getY(1),
    3699             :                 sPrecision.dfXYResolution);
    3700           1 :     delete poGeom;
    3701           1 : }
    3702             : 
    3703             : // Test discarding of bits in WKB export
    3704           4 : TEST_F(test_ogr, wkb_linestring_3d_discard_lsb_bits)
    3705             : {
    3706           2 :     OGRLineString oLS;
    3707           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, -1.2345678901234);
    3708           1 :     oLS.addPoint(-1.2345678901234, 1.2345678901234, 1.2345678901234);
    3709           1 :     OGRwkbExportOptions sOptions;
    3710           2 :     OGRGeomCoordinatePrecision sPrecision;
    3711           1 :     sPrecision.dfXYResolution = 1e-10;
    3712           1 :     sPrecision.dfZResolution = 1e-3;
    3713           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3714           2 :     std::vector<GByte> abyWKB(oLS.WkbSize());
    3715           1 :     oLS.exportToWkb(&abyWKB[0], &sOptions);
    3716           3 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3717             :     {
    3718           2 :         EXPECT_EQ(abyWKB[5 + 4 + 0 + 8 * i], 0);
    3719             :     }
    3720           1 :     OGRGeometry *poGeom = nullptr;
    3721           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3722           1 :     EXPECT_NE(poGeom->toLineString()->getX(0), oLS.getX(0));
    3723           1 :     EXPECT_NE(poGeom->toLineString()->getY(0), oLS.getY(0));
    3724           1 :     EXPECT_NE(poGeom->toLineString()->getZ(0), oLS.getZ(0));
    3725           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(0), oLS.getX(0),
    3726             :                 sPrecision.dfXYResolution);
    3727           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(0), oLS.getY(0),
    3728             :                 sPrecision.dfXYResolution);
    3729           1 :     EXPECT_NEAR(poGeom->toLineString()->getZ(0), oLS.getZ(0),
    3730             :                 sPrecision.dfZResolution);
    3731           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(1), oLS.getX(1),
    3732             :                 sPrecision.dfXYResolution);
    3733           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(1), oLS.getY(1),
    3734             :                 sPrecision.dfXYResolution);
    3735           1 :     EXPECT_NEAR(poGeom->toLineString()->getZ(1), oLS.getZ(1),
    3736             :                 sPrecision.dfZResolution);
    3737           1 :     delete poGeom;
    3738           1 : }
    3739             : 
    3740             : // Test discarding of bits in WKB export
    3741           4 : TEST_F(test_ogr, wkb_linestring_xym_discard_lsb_bits)
    3742             : {
    3743           2 :     OGRLineString oLS;
    3744           1 :     oLS.addPointM(1.2345678901234, -1.2345678901234, -1.2345678901234);
    3745           1 :     oLS.addPointM(-1.2345678901234, 1.2345678901234, 1.2345678901234);
    3746           1 :     OGRwkbExportOptions sOptions;
    3747           2 :     OGRGeomCoordinatePrecision sPrecision;
    3748           1 :     sPrecision.dfXYResolution = 1e-10;
    3749           1 :     sPrecision.dfMResolution = 1e-3;
    3750           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3751           2 :     std::vector<GByte> abyWKB(oLS.WkbSize());
    3752           1 :     oLS.exportToWkb(&abyWKB[0], &sOptions);
    3753           3 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3754             :     {
    3755           2 :         EXPECT_EQ(abyWKB[5 + 4 + 0 + 8 * i], 0);
    3756             :     }
    3757           1 :     OGRGeometry *poGeom = nullptr;
    3758           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3759           1 :     EXPECT_NE(poGeom->toLineString()->getX(0), oLS.getX(0));
    3760           1 :     EXPECT_NE(poGeom->toLineString()->getY(0), oLS.getY(0));
    3761           1 :     EXPECT_NE(poGeom->toLineString()->getM(0), oLS.getM(0));
    3762           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(0), oLS.getX(0),
    3763             :                 sPrecision.dfXYResolution);
    3764           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(0), oLS.getY(0),
    3765             :                 sPrecision.dfXYResolution);
    3766           1 :     EXPECT_NEAR(poGeom->toLineString()->getM(0), oLS.getM(0),
    3767             :                 sPrecision.dfMResolution);
    3768           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(1), oLS.getX(1),
    3769             :                 sPrecision.dfXYResolution);
    3770           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(1), oLS.getY(1),
    3771             :                 sPrecision.dfXYResolution);
    3772           1 :     EXPECT_NEAR(poGeom->toLineString()->getM(1), oLS.getM(1),
    3773             :                 sPrecision.dfMResolution);
    3774           1 :     delete poGeom;
    3775           1 : }
    3776             : 
    3777             : // Test discarding of bits in WKB export
    3778           4 : TEST_F(test_ogr, wkb_linestring_xyzm_discard_lsb_bits)
    3779             : {
    3780           2 :     OGRLineString oLS;
    3781           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, -1.2345678901234, 0.012345);
    3782           1 :     oLS.addPoint(-1.2345678901234, 1.2345678901234, 1.2345678901234, 0.012345);
    3783           1 :     OGRwkbExportOptions sOptions;
    3784           2 :     OGRGeomCoordinatePrecision sPrecision;
    3785           1 :     sPrecision.dfXYResolution = 1e-10;
    3786           1 :     sPrecision.dfZResolution = 1e-3;
    3787           1 :     sPrecision.dfMResolution = 1e-5;
    3788           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3789           2 :     std::vector<GByte> abyWKB(oLS.WkbSize());
    3790           1 :     oLS.exportToWkb(&abyWKB[0], &sOptions);
    3791           3 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3792             :     {
    3793           2 :         EXPECT_EQ(abyWKB[5 + 4 + 0 + 8 * i], 0);
    3794             :     }
    3795           1 :     OGRGeometry *poGeom = nullptr;
    3796           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3797           1 :     EXPECT_NE(poGeom->toLineString()->getX(0), oLS.getX(0));
    3798           1 :     EXPECT_NE(poGeom->toLineString()->getY(0), oLS.getY(0));
    3799           1 :     EXPECT_NE(poGeom->toLineString()->getZ(0), oLS.getZ(0));
    3800           1 :     EXPECT_NE(poGeom->toLineString()->getM(0), oLS.getM(0));
    3801           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(0), oLS.getX(0),
    3802             :                 sPrecision.dfXYResolution);
    3803           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(0), oLS.getY(0),
    3804             :                 sPrecision.dfXYResolution);
    3805           1 :     EXPECT_NEAR(poGeom->toLineString()->getZ(0), oLS.getZ(0),
    3806             :                 sPrecision.dfZResolution);
    3807           1 :     EXPECT_NEAR(poGeom->toLineString()->getM(0), oLS.getM(0),
    3808             :                 sPrecision.dfMResolution);
    3809           1 :     EXPECT_NEAR(poGeom->toLineString()->getX(1), oLS.getX(1),
    3810             :                 sPrecision.dfXYResolution);
    3811           1 :     EXPECT_NEAR(poGeom->toLineString()->getY(1), oLS.getY(1),
    3812             :                 sPrecision.dfXYResolution);
    3813           1 :     EXPECT_NEAR(poGeom->toLineString()->getZ(1), oLS.getZ(1),
    3814             :                 sPrecision.dfZResolution);
    3815           1 :     EXPECT_NEAR(poGeom->toLineString()->getM(1), oLS.getM(1),
    3816             :                 sPrecision.dfMResolution);
    3817           1 :     delete poGeom;
    3818           1 : }
    3819             : 
    3820             : // Test discarding of bits in WKB export
    3821           4 : TEST_F(test_ogr, wkb_polygon_2d_xy_precision)
    3822             : {
    3823           2 :     OGRLinearRing oLS;
    3824           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234);
    3825           1 :     oLS.addPoint(-1.2345678901234, -1.2345678901234);
    3826           1 :     oLS.addPoint(-2.2345678901234, 1.2345678901234);
    3827           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234);
    3828           2 :     OGRPolygon oPoly;
    3829           1 :     oPoly.addRing(&oLS);
    3830           1 :     OGRwkbExportOptions sOptions;
    3831           2 :     OGRGeomCoordinatePrecision sPrecision;
    3832           1 :     sPrecision.dfXYResolution = 1e-10;
    3833           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3834           2 :     std::vector<GByte> abyWKB(oPoly.WkbSize());
    3835           1 :     oPoly.exportToWkb(&abyWKB[0], &sOptions);
    3836           5 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3837             :     {
    3838           4 :         EXPECT_EQ(abyWKB[5 + 4 + 4 + 0 + 8 * i], 0);
    3839             :     }
    3840           1 :     OGRGeometry *poGeom = nullptr;
    3841           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3842           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0));
    3843           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0));
    3844           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0),
    3845             :                 sPrecision.dfXYResolution);
    3846           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0),
    3847             :                 sPrecision.dfXYResolution);
    3848           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(1), oLS.getX(1),
    3849             :                 sPrecision.dfXYResolution);
    3850           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(1), oLS.getY(1),
    3851             :                 sPrecision.dfXYResolution);
    3852           1 :     delete poGeom;
    3853           1 : }
    3854             : 
    3855             : // Test discarding of bits in WKB export
    3856           4 : TEST_F(test_ogr, wkb_polygon_3d_discard_lsb_bits)
    3857             : {
    3858           2 :     OGRLinearRing oLS;
    3859           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, 1.2345678901234);
    3860           1 :     oLS.addPoint(-1.2345678901234, -1.2345678901234, -1.2345678901234);
    3861           1 :     oLS.addPoint(-2.2345678901234, 1.2345678901234, -1.2345678901234);
    3862           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, 1.2345678901234);
    3863           2 :     OGRPolygon oPoly;
    3864           1 :     oPoly.addRing(&oLS);
    3865           2 :     OGRSpatialReference oSRS;
    3866           1 :     oSRS.importFromEPSG(4326);
    3867           1 :     OGRwkbExportOptions sOptions;
    3868           2 :     OGRGeomCoordinatePrecision sPrecision;
    3869           1 :     sPrecision.SetFromMeter(&oSRS, 1e-3, 1e-3, 0);
    3870           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3871           2 :     std::vector<GByte> abyWKB(oPoly.WkbSize());
    3872           1 :     oPoly.exportToWkb(&abyWKB[0], &sOptions);
    3873           5 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3874             :     {
    3875           4 :         EXPECT_EQ(abyWKB[5 + 4 + 4 + 0 + 8 * i], 0);
    3876             :     }
    3877           1 :     OGRGeometry *poGeom = nullptr;
    3878           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3879           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0));
    3880           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0));
    3881           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getZ(0), oLS.getZ(0));
    3882           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0),
    3883             :                 8.9e-9);
    3884           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0),
    3885             :                 8.9e-9);
    3886           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getZ(0), oLS.getZ(0),
    3887             :                 1e-3);
    3888           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(1), oLS.getX(1),
    3889             :                 8.9e-9);
    3890           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(1), oLS.getY(1),
    3891             :                 8.9e-9);
    3892           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getZ(1), oLS.getZ(1),
    3893             :                 1e-3);
    3894           1 :     delete poGeom;
    3895           1 : }
    3896             : 
    3897             : // Test discarding of bits in WKB export
    3898           4 : TEST_F(test_ogr, wkb_polygon_xym_discard_lsb_bits)
    3899             : {
    3900           2 :     OGRLinearRing oLS;
    3901           1 :     oLS.addPointM(1.2345678901234, -1.2345678901234, 1.2345678901234);
    3902           1 :     oLS.addPointM(-1.2345678901234, -1.2345678901234, -1.2345678901234);
    3903           1 :     oLS.addPointM(-2.2345678901234, 1.2345678901234, -1.2345678901234);
    3904           1 :     oLS.addPointM(1.2345678901234, -1.2345678901234, 1.2345678901234);
    3905           2 :     OGRPolygon oPoly;
    3906           1 :     oPoly.addRing(&oLS);
    3907           2 :     OGRSpatialReference oSRS;
    3908           1 :     oSRS.importFromEPSG(4326);
    3909           1 :     OGRwkbExportOptions sOptions;
    3910           2 :     OGRGeomCoordinatePrecision sPrecision;
    3911           1 :     sPrecision.SetFromMeter(&oSRS, 1e-3, 0, 1e-3);
    3912           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3913           2 :     std::vector<GByte> abyWKB(oPoly.WkbSize());
    3914           1 :     oPoly.exportToWkb(&abyWKB[0], &sOptions);
    3915           5 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3916             :     {
    3917           4 :         EXPECT_EQ(abyWKB[5 + 4 + 4 + 0 + 8 * i], 0);
    3918             :     }
    3919           1 :     OGRGeometry *poGeom = nullptr;
    3920           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3921           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0));
    3922           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0));
    3923           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getM(0), oLS.getM(0));
    3924           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0),
    3925             :                 8.9e-9);
    3926           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0),
    3927             :                 8.9e-9);
    3928           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getM(0), oLS.getM(0),
    3929             :                 1e-3);
    3930           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(1), oLS.getX(1),
    3931             :                 8.9e-9);
    3932           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(1), oLS.getY(1),
    3933             :                 8.9e-9);
    3934           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getM(1), oLS.getM(1),
    3935             :                 1e-3);
    3936           1 :     delete poGeom;
    3937           1 : }
    3938             : 
    3939             : // Test discarding of bits in WKB export
    3940           4 : TEST_F(test_ogr, wkb_polygon_xyzm_discard_lsb_bits)
    3941             : {
    3942           2 :     OGRLinearRing oLS;
    3943           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, 1.2345678901234, 0.012345);
    3944           1 :     oLS.addPoint(-1.2345678901234, -1.2345678901234, -1.2345678901234, 12345);
    3945           1 :     oLS.addPoint(-2.2345678901234, 1.2345678901234, -1.2345678901234, 0.012345);
    3946           1 :     oLS.addPoint(1.2345678901234, -1.2345678901234, 1.2345678901234, 0.012345);
    3947           2 :     OGRPolygon oPoly;
    3948           1 :     oPoly.addRing(&oLS);
    3949           2 :     OGRSpatialReference oSRS;
    3950           1 :     oSRS.importFromEPSG(4326);
    3951           1 :     OGRwkbExportOptions sOptions;
    3952           2 :     OGRGeomCoordinatePrecision sPrecision;
    3953           1 :     sPrecision.SetFromMeter(&oSRS, 1e-3, 1e-3, 1e-4);
    3954           1 :     sOptions.sPrecision.SetFrom(sPrecision);
    3955           2 :     std::vector<GByte> abyWKB(oPoly.WkbSize());
    3956           1 :     oPoly.exportToWkb(&abyWKB[0], &sOptions);
    3957           5 :     for (int i = 0; i < oLS.getDimension() * oLS.getNumPoints(); ++i)
    3958             :     {
    3959           4 :         EXPECT_EQ(abyWKB[5 + 4 + 4 + 0 + 8 * i], 0);
    3960             :     }
    3961           1 :     OGRGeometry *poGeom = nullptr;
    3962           1 :     OGRGeometryFactory::createFromWkb(abyWKB.data(), nullptr, &poGeom);
    3963           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0));
    3964           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0));
    3965           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getZ(0), oLS.getZ(0));
    3966           1 :     EXPECT_NE(poGeom->toPolygon()->getExteriorRing()->getM(0), oLS.getM(0));
    3967           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(0), oLS.getX(0),
    3968             :                 8.9e-9);
    3969           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(0), oLS.getY(0),
    3970             :                 8.9e-9);
    3971           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getZ(0), oLS.getZ(0),
    3972             :                 1e-3);
    3973           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getM(0), oLS.getM(0),
    3974             :                 1e-4);
    3975           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getX(1), oLS.getX(1),
    3976             :                 8.9e-9);
    3977           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getY(1), oLS.getY(1),
    3978             :                 8.9e-9);
    3979           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getZ(1), oLS.getZ(1),
    3980             :                 1e-3);
    3981           1 :     EXPECT_NEAR(poGeom->toPolygon()->getExteriorRing()->getM(1), oLS.getM(1),
    3982             :                 1e-4);
    3983           1 :     delete poGeom;
    3984           1 : }
    3985             : 
    3986             : // Test OGRFeature::SerializeToBinary() and DeserializeFromBinary();
    3987           4 : TEST_F(test_ogr, OGRFeature_SerializeToBinary)
    3988             : {
    3989             :     {
    3990           2 :         OGRFeatureDefn oFDefn;
    3991           1 :         oFDefn.SetGeomType(wkbNone);
    3992           1 :         oFDefn.Reference();
    3993             : 
    3994             :         {
    3995           2 :             OGRFeature oFeatSrc(&oFDefn);
    3996           1 :             oFeatSrc.SetFID(1);
    3997           2 :             std::vector<GByte> abyBuffer;
    3998             : 
    3999           1 :             EXPECT_TRUE(oFeatSrc.SerializeToBinary(abyBuffer));
    4000           1 :             EXPECT_EQ(abyBuffer.size(), 1);
    4001           1 :             EXPECT_EQ(abyBuffer[0], 1);
    4002             : 
    4003           2 :             OGRFeature oFeatDst(&oFDefn);
    4004           1 :             EXPECT_FALSE(oFeatDst.DeserializeFromBinary(abyBuffer.data(), 0));
    4005           1 :             EXPECT_TRUE(oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4006             :                                                        abyBuffer.size()));
    4007           1 :             EXPECT_EQ(oFeatDst.GetFID(), 1);
    4008             :         }
    4009             : 
    4010             :         {
    4011           2 :             OGRFeature oFeatSrc(&oFDefn);
    4012           1 :             oFeatSrc.SetFID(static_cast<GIntBig>(-12345678901234));
    4013           2 :             std::vector<GByte> abyBuffer;
    4014             : 
    4015           1 :             EXPECT_TRUE(oFeatSrc.SerializeToBinary(abyBuffer));
    4016             : 
    4017           2 :             OGRFeature oFeatDst(&oFDefn);
    4018             :             // Try truncated buffers
    4019           8 :             for (size_t i = 0; i < abyBuffer.size(); ++i)
    4020             :             {
    4021           7 :                 EXPECT_FALSE(
    4022             :                     oFeatDst.DeserializeFromBinary(abyBuffer.data(), i));
    4023             :             }
    4024           1 :             EXPECT_TRUE(oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4025             :                                                        abyBuffer.size()));
    4026           1 :             EXPECT_EQ(oFeatDst.GetFID(), static_cast<GIntBig>(-12345678901234));
    4027             :         }
    4028             :     }
    4029             : 
    4030             :     {
    4031           1 :         OGRFeatureDefn oFDefn;
    4032           1 :         oFDefn.Reference();
    4033             :         {
    4034           2 :             OGRFieldDefn oFieldDefn("int", OFTInteger);
    4035           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4036             :         }
    4037             :         {
    4038           2 :             OGRFieldDefn oFieldDefn("int64", OFTInteger64);
    4039           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4040             :         }
    4041             :         {
    4042           2 :             OGRFieldDefn oFieldDefn("real", OFTReal);
    4043           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4044             :         }
    4045             :         {
    4046           2 :             OGRFieldDefn oFieldDefn("str", OFTString);
    4047           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4048             :         }
    4049             :         {
    4050           2 :             OGRFieldDefn oFieldDefn("binary", OFTBinary);
    4051           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4052             :         }
    4053             :         {
    4054           2 :             OGRFieldDefn oFieldDefn("intlist", OFTIntegerList);
    4055           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4056             :         }
    4057             :         {
    4058           2 :             OGRFieldDefn oFieldDefn("int64list", OFTInteger64List);
    4059           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4060             :         }
    4061             :         {
    4062           2 :             OGRFieldDefn oFieldDefn("reallist", OFTRealList);
    4063           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4064             :         }
    4065             :         {
    4066           2 :             OGRFieldDefn oFieldDefn("strlist", OFTStringList);
    4067           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4068             :         }
    4069             :         {
    4070           2 :             OGRFieldDefn oFieldDefn("date", OFTDate);
    4071           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4072             :         }
    4073             :         {
    4074           2 :             OGRFieldDefn oFieldDefn("time", OFTTime);
    4075           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4076             :         }
    4077             :         {
    4078           2 :             OGRFieldDefn oFieldDefn("datetime", OFTDateTime);
    4079           1 :             oFDefn.AddFieldDefn(&oFieldDefn);
    4080             :         }
    4081             : 
    4082             :         {
    4083           2 :             OGRFeature oFeatSrc(&oFDefn);
    4084           2 :             std::vector<GByte> abyBuffer;
    4085             : 
    4086           1 :             EXPECT_TRUE(oFeatSrc.SerializeToBinary(abyBuffer));
    4087           1 :             EXPECT_EQ(abyBuffer.size(), 5);
    4088             : 
    4089           2 :             OGRFeature oFeatDst(&oFDefn);
    4090           6 :             for (size_t i = 0; i < abyBuffer.size(); ++i)
    4091             :             {
    4092           5 :                 EXPECT_FALSE(
    4093             :                     oFeatDst.DeserializeFromBinary(abyBuffer.data(), i));
    4094             :             }
    4095           1 :             EXPECT_TRUE(oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4096             :                                                        abyBuffer.size()));
    4097           1 :             EXPECT_TRUE(oFeatDst.Equal(&oFeatSrc));
    4098             :         }
    4099             : 
    4100             :         {
    4101           1 :             OGRFeature oFeatSrc(&oFDefn);
    4102           1 :             std::vector<GByte> abyBuffer;
    4103             : 
    4104           1 :             const int iFieldInt = oFDefn.GetFieldIndex("int");
    4105           1 :             ASSERT_TRUE(iFieldInt >= 0);
    4106           1 :             oFeatSrc.SetFieldNull(iFieldInt);
    4107           1 :             EXPECT_TRUE(oFeatSrc.SerializeToBinary(abyBuffer));
    4108           1 :             EXPECT_EQ(abyBuffer.size(), 5);
    4109             : 
    4110           2 :             OGRFeature oFeatDst(&oFDefn);
    4111             : 
    4112             :             // Try truncated buffers
    4113           6 :             for (size_t i = 0; i < abyBuffer.size(); ++i)
    4114             :             {
    4115           5 :                 EXPECT_FALSE(
    4116             :                     oFeatDst.DeserializeFromBinary(abyBuffer.data(), i));
    4117             :             }
    4118             : 
    4119           1 :             EXPECT_TRUE(oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4120             :                                                        abyBuffer.size()));
    4121           1 :             EXPECT_TRUE(oFeatDst.Equal(&oFeatSrc));
    4122             :         }
    4123             : 
    4124             :         {
    4125           1 :             OGRFeature oFeatSrc(&oFDefn);
    4126           1 :             oFeatSrc.SetFID(1);
    4127           1 :             oFeatSrc.SetField("int", -123);
    4128           1 :             oFeatSrc.SetField("int64", static_cast<GIntBig>(-12345678901234));
    4129           1 :             oFeatSrc.SetField("real", 1.25);
    4130           1 :             oFeatSrc.SetField("str", "foo");
    4131           1 :             const int iFieldBinary = oFDefn.GetFieldIndex("binary");
    4132           1 :             ASSERT_TRUE(iFieldBinary >= 0);
    4133           1 :             oFeatSrc.SetField(iFieldBinary, 3,
    4134             :                               static_cast<const void *>("abc"));
    4135           1 :             oFeatSrc.SetField("intlist", 2,
    4136           2 :                               std::vector<int>{1, -123456}.data());
    4137           1 :             oFeatSrc.SetField("int64list", 2,
    4138           2 :                               std::vector<GIntBig>{1, -12345678901234}.data());
    4139           1 :             oFeatSrc.SetField("reallist", 2,
    4140           2 :                               std::vector<double>{1.5, -2.5}.data());
    4141           2 :             CPLStringList aosList;
    4142           1 :             aosList.AddString("foo");
    4143           1 :             aosList.AddString("barbaz");
    4144           1 :             oFeatSrc.SetField("strlist", aosList.List());
    4145           1 :             oFeatSrc.SetField("date", 2023, 1, 3);
    4146           1 :             oFeatSrc.SetField("time", 0, 0, 0, 12, 34, 56.789f);
    4147           1 :             oFeatSrc.SetField("datetime", 2023, 1, 3, 12, 34, 56.789f);
    4148           2 :             OGRPoint p(1, 2);
    4149           1 :             oFeatSrc.SetGeometry(&p);
    4150           2 :             std::vector<GByte> abyBuffer;
    4151             : 
    4152           1 :             EXPECT_TRUE(oFeatSrc.SerializeToBinary(abyBuffer));
    4153             : 
    4154           2 :             OGRFeature oFeatDst(&oFDefn);
    4155             : 
    4156             :             // Try truncated buffers
    4157         118 :             for (size_t i = 0; i < abyBuffer.size(); ++i)
    4158             :             {
    4159         117 :                 EXPECT_FALSE(
    4160             :                     oFeatDst.DeserializeFromBinary(abyBuffer.data(), i));
    4161             :             }
    4162             : 
    4163             :             // Try corrupted buffers
    4164             :             {
    4165           2 :                 CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4166         118 :                 for (size_t i = 0; i < abyBuffer.size(); ++i)
    4167             :                 {
    4168             :                     // Might succeed or fail, but shouldn't crash..
    4169         117 :                     const GByte backup = abyBuffer[i];
    4170         117 :                     abyBuffer[i] = static_cast<GByte>(~abyBuffer[i]);
    4171         117 :                     (void)oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4172             :                                                          abyBuffer.size());
    4173         117 :                     abyBuffer[i] = backup;
    4174             :                 }
    4175             :             }
    4176             : 
    4177           1 :             EXPECT_TRUE(oFeatDst.DeserializeFromBinary(abyBuffer.data(),
    4178             :                                                        abyBuffer.size()));
    4179             :             // oFeatSrc.DumpReadable(stdout);
    4180             :             // oFeatDst.DumpReadable(stdout);
    4181           1 :             EXPECT_TRUE(oFeatDst.Equal(&oFeatSrc));
    4182             :         }
    4183             :     }
    4184             : }
    4185             : 
    4186             : // Test OGRGeometry::IsRectangle()
    4187           4 : TEST_F(test_ogr, OGRGeometry_IsRectangle)
    4188             : {
    4189             :     // Not a polygon
    4190             :     {
    4191           1 :         OGRGeometry *poGeom = nullptr;
    4192           1 :         OGRGeometryFactory::createFromWkt("POINT EMPTY", nullptr, &poGeom);
    4193           1 :         ASSERT_NE(poGeom, nullptr);
    4194           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4195           1 :         delete poGeom;
    4196             :     }
    4197             :     // Polygon empty
    4198             :     {
    4199           1 :         OGRGeometry *poGeom = nullptr;
    4200           1 :         OGRGeometryFactory::createFromWkt("POLYGON EMPTY", nullptr, &poGeom);
    4201           1 :         ASSERT_NE(poGeom, nullptr);
    4202           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4203           1 :         delete poGeom;
    4204             :     }
    4205             :     // Polygon with inner ring
    4206             :     {
    4207           1 :         OGRGeometry *poGeom = nullptr;
    4208           1 :         OGRGeometryFactory::createFromWkt(
    4209             :             "POLYGON ((0 0,0 1,1 1,1 0,0 0),(0.2 0.2,0.2 0.8,0.8 0.8,0.8 "
    4210             :             "0.2,0.2 0.2))",
    4211             :             nullptr, &poGeom);
    4212           1 :         ASSERT_NE(poGeom, nullptr);
    4213           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4214           1 :         delete poGeom;
    4215             :     }
    4216             :     // Polygon with 3 points
    4217             :     {
    4218           1 :         OGRGeometry *poGeom = nullptr;
    4219           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1,1 1))", nullptr,
    4220             :                                           &poGeom);
    4221           1 :         ASSERT_NE(poGeom, nullptr);
    4222           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4223           1 :         delete poGeom;
    4224             :     }
    4225             :     // Polygon with 6 points
    4226             :     {
    4227           1 :         OGRGeometry *poGeom = nullptr;
    4228           1 :         OGRGeometryFactory::createFromWkt(
    4229             :             "POLYGON ((0 0,0.1 0,0.2 0,0.3 0,1 1,0 0))", nullptr, &poGeom);
    4230           1 :         ASSERT_NE(poGeom, nullptr);
    4231           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4232           1 :         delete poGeom;
    4233             :     }
    4234             :     // Polygon with 5 points, but last one not matching first (invalid)
    4235             :     {
    4236           1 :         OGRGeometry *poGeom = nullptr;
    4237           1 :         OGRGeometryFactory::createFromWkt(
    4238             :             "POLYGON ((0 0,0 1,1 1,1 0,-999 -999))", nullptr, &poGeom);
    4239           1 :         ASSERT_NE(poGeom, nullptr);
    4240           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4241           1 :         delete poGeom;
    4242             :     }
    4243             :     // Polygon with 5 points, but not rectangle
    4244             :     {
    4245           1 :         OGRGeometry *poGeom = nullptr;
    4246           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1.1,1 1,1 0,0 0))",
    4247             :                                           nullptr, &poGeom);
    4248           1 :         ASSERT_NE(poGeom, nullptr);
    4249           1 :         EXPECT_FALSE(poGeom->IsRectangle());
    4250           1 :         delete poGeom;
    4251             :     }
    4252             :     // Rectangle (type 1)
    4253             :     {
    4254           1 :         OGRGeometry *poGeom = nullptr;
    4255           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1,1 1,1 0,0 0))",
    4256             :                                           nullptr, &poGeom);
    4257           1 :         ASSERT_NE(poGeom, nullptr);
    4258           1 :         EXPECT_TRUE(poGeom->IsRectangle());
    4259           1 :         delete poGeom;
    4260             :     }
    4261             :     // Rectangle2(type 1)
    4262             :     {
    4263           1 :         OGRGeometry *poGeom = nullptr;
    4264           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,1 0,1 1,0 1,0 0))",
    4265             :                                           nullptr, &poGeom);
    4266           1 :         ASSERT_NE(poGeom, nullptr);
    4267           1 :         EXPECT_TRUE(poGeom->IsRectangle());
    4268           1 :         delete poGeom;
    4269             :     }
    4270             : }
    4271             : 
    4272             : // Test OGRGeometry::removeEmptyParts()
    4273           4 : TEST_F(test_ogr, OGRGeometry_removeEmptyParts)
    4274             : {
    4275             :     {
    4276           1 :         OGRGeometry *poGeom = nullptr;
    4277           1 :         OGRGeometryFactory::createFromWkt("POINT EMPTY", nullptr, &poGeom);
    4278           1 :         ASSERT_NE(poGeom, nullptr);
    4279           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4280           1 :         poGeom->removeEmptyParts();
    4281           1 :         EXPECT_TRUE(poGeom->IsEmpty());
    4282           1 :         delete poGeom;
    4283             :     }
    4284             :     {
    4285           1 :         OGRGeometry *poGeom = nullptr;
    4286           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1,1 0,0 0))",
    4287             :                                           nullptr, &poGeom);
    4288           1 :         ASSERT_NE(poGeom, nullptr);
    4289           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4290           1 :         poGeom->removeEmptyParts();
    4291           1 :         EXPECT_NE(poGeom->toPolygon()->getExteriorRing(), nullptr);
    4292           1 :         delete poGeom;
    4293             :     }
    4294             :     {
    4295           1 :         OGRGeometry *poGeom = nullptr;
    4296           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1,1 0,0 0))",
    4297             :                                           nullptr, &poGeom);
    4298           1 :         ASSERT_NE(poGeom, nullptr);
    4299           1 :         poGeom->toPolygon()->addRingDirectly(new OGRLinearRing());
    4300           1 :         EXPECT_EQ(poGeom->toPolygon()->getNumInteriorRings(), 1);
    4301           1 :         EXPECT_TRUE(poGeom->hasEmptyParts());
    4302           1 :         poGeom->removeEmptyParts();
    4303           1 :         EXPECT_NE(poGeom->toPolygon()->getExteriorRing(), nullptr);
    4304           1 :         EXPECT_EQ(poGeom->toPolygon()->getNumInteriorRings(), 0);
    4305           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4306           1 :         delete poGeom;
    4307             :     }
    4308             :     {
    4309           1 :         OGRGeometry *poGeom = nullptr;
    4310           1 :         OGRGeometryFactory::createFromWkt("COMPOUNDCURVE ((0 0,1 1))", nullptr,
    4311             :                                           &poGeom);
    4312           1 :         ASSERT_NE(poGeom, nullptr);
    4313           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4314           1 :         poGeom->removeEmptyParts();
    4315           1 :         EXPECT_EQ(poGeom->toCompoundCurve()->getNumCurves(), 1);
    4316           1 :         delete poGeom;
    4317             :     }
    4318             :     {
    4319           1 :         OGRGeometry *poGeom = nullptr;
    4320           1 :         OGRGeometryFactory::createFromWkt("COMPOUNDCURVE ((0 0,1 1),(1 1,2 2))",
    4321             :                                           nullptr, &poGeom);
    4322           1 :         ASSERT_NE(poGeom, nullptr);
    4323           1 :         poGeom->toCompoundCurve()->getCurve(1)->empty();
    4324           1 :         EXPECT_EQ(poGeom->toCompoundCurve()->getNumCurves(), 2);
    4325           1 :         EXPECT_TRUE(poGeom->hasEmptyParts());
    4326           1 :         poGeom->removeEmptyParts();
    4327           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4328           1 :         EXPECT_EQ(poGeom->toCompoundCurve()->getNumCurves(), 1);
    4329           1 :         delete poGeom;
    4330             :     }
    4331             :     {
    4332           1 :         OGRGeometry *poGeom = nullptr;
    4333           1 :         OGRGeometryFactory::createFromWkt("GEOMETRYCOLLECTION (POINT(0 0))",
    4334             :                                           nullptr, &poGeom);
    4335           1 :         ASSERT_NE(poGeom, nullptr);
    4336           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4337           1 :         poGeom->removeEmptyParts();
    4338           1 :         EXPECT_EQ(poGeom->toGeometryCollection()->getNumGeometries(), 1);
    4339           1 :         delete poGeom;
    4340             :     }
    4341             :     {
    4342           1 :         OGRGeometry *poGeom = nullptr;
    4343           1 :         OGRGeometryFactory::createFromWkt(
    4344             :             "GEOMETRYCOLLECTION (POINT EMPTY,POINT(0 0),POINT EMPTY)", nullptr,
    4345             :             &poGeom);
    4346           1 :         ASSERT_NE(poGeom, nullptr);
    4347           1 :         EXPECT_EQ(poGeom->toGeometryCollection()->getNumGeometries(), 3);
    4348           1 :         EXPECT_TRUE(poGeom->hasEmptyParts());
    4349           1 :         poGeom->removeEmptyParts();
    4350           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4351           1 :         EXPECT_EQ(poGeom->toGeometryCollection()->getNumGeometries(), 1);
    4352           1 :         delete poGeom;
    4353             :     }
    4354             :     {
    4355           1 :         OGRGeometry *poGeom = nullptr;
    4356           1 :         OGRGeometryFactory::createFromWkt("GEOMETRYCOLLECTION EMPTY", nullptr,
    4357             :                                           &poGeom);
    4358           1 :         ASSERT_NE(poGeom, nullptr);
    4359           1 :         OGRGeometry *poPoly = nullptr;
    4360           1 :         OGRGeometryFactory::createFromWkt("POLYGON ((0 0,0 1,1 0,0 0))",
    4361             :                                           nullptr, &poPoly);
    4362           1 :         EXPECT_NE(poPoly, nullptr);
    4363           1 :         if (poPoly)
    4364             :         {
    4365           1 :             poPoly->toPolygon()->addRingDirectly(new OGRLinearRing());
    4366           1 :             poGeom->toGeometryCollection()->addGeometryDirectly(poPoly);
    4367           1 :             EXPECT_EQ(poGeom->toGeometryCollection()->getNumGeometries(), 1);
    4368           1 :             EXPECT_TRUE(poGeom->hasEmptyParts());
    4369           1 :             poGeom->removeEmptyParts();
    4370           1 :             EXPECT_FALSE(poGeom->hasEmptyParts());
    4371           1 :             EXPECT_EQ(poGeom->toGeometryCollection()->getNumGeometries(), 1);
    4372             :         }
    4373           1 :         delete poGeom;
    4374             :     }
    4375             :     {
    4376           1 :         OGRGeometry *poGeom = nullptr;
    4377           1 :         OGRGeometryFactory::createFromWkt(
    4378             :             "POLYHEDRALSURFACE (((0 0,0 1,1 1,0 0)))", nullptr, &poGeom);
    4379           1 :         ASSERT_NE(poGeom, nullptr);
    4380           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4381           1 :         poGeom->removeEmptyParts();
    4382           1 :         EXPECT_EQ(poGeom->toPolyhedralSurface()->getNumGeometries(), 1);
    4383           1 :         delete poGeom;
    4384             :     }
    4385             :     {
    4386           1 :         OGRGeometry *poGeom = nullptr;
    4387           1 :         OGRGeometryFactory::createFromWkt(
    4388             :             "POLYHEDRALSURFACE (((0 0,0 1,1 1,0 0)))", nullptr, &poGeom);
    4389           1 :         ASSERT_NE(poGeom, nullptr);
    4390           1 :         poGeom->toPolyhedralSurface()->addGeometryDirectly(new OGRPolygon());
    4391           1 :         EXPECT_EQ(poGeom->toPolyhedralSurface()->getNumGeometries(), 2);
    4392           1 :         EXPECT_TRUE(poGeom->hasEmptyParts());
    4393           1 :         poGeom->removeEmptyParts();
    4394           1 :         EXPECT_FALSE(poGeom->hasEmptyParts());
    4395           1 :         EXPECT_EQ(poGeom->toPolyhedralSurface()->getNumGeometries(), 1);
    4396           1 :         delete poGeom;
    4397             :     }
    4398             : }
    4399             : 
    4400             : // Test OGRCurve::reversePoints()
    4401           4 : TEST_F(test_ogr, OGRCurve_reversePoints)
    4402             : {
    4403             :     {
    4404           1 :         OGRGeometry *poGeom = nullptr;
    4405           1 :         OGRGeometryFactory::createFromWkt(
    4406             :             "COMPOUNDCURVE ZM (CIRCULARSTRING ZM (0 0 10 20,1 1 11 21,2 0 12 "
    4407             :             "22),(2 0 12 22,3 0 13 2))",
    4408             :             nullptr, &poGeom);
    4409           1 :         ASSERT_NE(poGeom, nullptr);
    4410           1 :         poGeom->toCurve()->reversePoints();
    4411           1 :         char *pszWKT = nullptr;
    4412           1 :         poGeom->exportToWkt(&pszWKT, wkbVariantIso);
    4413           1 :         EXPECT_TRUE(pszWKT != nullptr);
    4414           1 :         if (pszWKT)
    4415             :         {
    4416           1 :             EXPECT_STREQ(
    4417             :                 pszWKT, "COMPOUNDCURVE ZM ((3 0 13 2,2 0 12 22),CIRCULARSTRING "
    4418             :                         "ZM (2 0 12 22,1 1 11 21,0 0 10 20))");
    4419             :         }
    4420           1 :         CPLFree(pszWKT);
    4421           1 :         delete poGeom;
    4422             :     }
    4423             : }
    4424             : 
    4425             : // Test OGRGeometryFactory::transformWithOptions()
    4426           4 : TEST_F(test_ogr, transformWithOptions)
    4427             : {
    4428             :     // Projected CRS to national geographic CRS (not including poles or antimeridian)
    4429           1 :     auto [poGeom, err] = OGRGeometryFactory::createFromWkt(
    4430           1 :         "LINESTRING(700000 6600000, 700001 6600001)");
    4431           1 :     ASSERT_NE(poGeom, nullptr);
    4432             : 
    4433           1 :     OGRSpatialReference oEPSG_2154;
    4434           1 :     oEPSG_2154.importFromEPSG(2154);  // "RGF93 v1 / Lambert-93"
    4435           1 :     OGRSpatialReference oEPSG_4171;
    4436           1 :     oEPSG_4171.importFromEPSG(4171);  // "RGF93 v1"
    4437           1 :     oEPSG_4171.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    4438             :     auto poCT = std::unique_ptr<OGRCoordinateTransformation>(
    4439           1 :         OGRCreateCoordinateTransformation(&oEPSG_2154, &oEPSG_4171));
    4440           1 :     OGRGeometryFactory::TransformWithOptionsCache oCache;
    4441             :     auto poNewGeom =
    4442             :         std::unique_ptr<OGRGeometry>(OGRGeometryFactory::transformWithOptions(
    4443           1 :             poGeom.get(), poCT.get(), nullptr, oCache));
    4444           1 :     ASSERT_NE(poNewGeom, nullptr);
    4445           1 :     EXPECT_NEAR(poNewGeom->toLineString()->getX(0), 3, 1e-8);
    4446           1 :     EXPECT_NEAR(poNewGeom->toLineString()->getY(0), 46.5, 1e-8);
    4447             : }
    4448             : 
    4449             : #ifdef HAVE_GEOS
    4450             : 
    4451             : // Test OGRGeometryFactory::transformWithOptions()
    4452           4 : TEST_F(test_ogr, transformWithOptions_GEOS)
    4453             : {
    4454             :     // Projected CRS to national geographic CRS including antimeridian
    4455           1 :     auto [poGeom, err] = OGRGeometryFactory::createFromWkt(
    4456           1 :         "LINESTRING(657630.64 4984896.17,815261.43 4990738.26)");
    4457           1 :     ASSERT_NE(poGeom, nullptr);
    4458             : 
    4459           1 :     OGRSpatialReference oEPSG_6329;
    4460           1 :     oEPSG_6329.importFromEPSG(6329);  // "NAD83(2011) / UTM zone 60N"
    4461           1 :     OGRSpatialReference oEPSG_6318;
    4462           1 :     oEPSG_6318.importFromEPSG(6318);  // "NAD83(2011)"
    4463           1 :     oEPSG_6318.SetAxisMappingStrategy(OAMS_TRADITIONAL_GIS_ORDER);
    4464             :     auto poCT = std::unique_ptr<OGRCoordinateTransformation>(
    4465           1 :         OGRCreateCoordinateTransformation(&oEPSG_6329, &oEPSG_6318));
    4466           1 :     OGRGeometryFactory::TransformWithOptionsCache oCache;
    4467             :     auto poNewGeom =
    4468             :         std::unique_ptr<OGRGeometry>(OGRGeometryFactory::transformWithOptions(
    4469           1 :             poGeom.get(), poCT.get(), nullptr, oCache));
    4470           1 :     ASSERT_NE(poNewGeom, nullptr);
    4471           1 :     EXPECT_EQ(poNewGeom->getGeometryType(), wkbMultiLineString);
    4472           1 :     if (poNewGeom->getGeometryType() == wkbMultiLineString)
    4473             :     {
    4474           1 :         const auto poMLS = poNewGeom->toMultiLineString();
    4475           1 :         EXPECT_EQ(poMLS->getNumGeometries(), 2);
    4476           1 :         if (poMLS->getNumGeometries() == 2)
    4477             :         {
    4478           1 :             const auto poLS = poMLS->getGeometryRef(0);
    4479           1 :             EXPECT_EQ(poLS->getNumPoints(), 2);
    4480           1 :             if (poLS->getNumPoints() == 2)
    4481             :             {
    4482           1 :                 EXPECT_NEAR(poLS->getX(0), 179, 1e-6);
    4483           1 :                 EXPECT_NEAR(poLS->getY(0), 45, 1e-6);
    4484           1 :                 EXPECT_NEAR(poLS->getX(1), 180, 1e-6);
    4485           1 :                 EXPECT_NEAR(poLS->getY(1), 45.004384301691303, 1e-6);
    4486             :             }
    4487             :         }
    4488             :     }
    4489             : }
    4490             : #endif
    4491             : 
    4492             : // Test OGRCurvePolygon::addRingDirectly
    4493           4 : TEST_F(test_ogr, OGRCurvePolygon_addRingDirectly)
    4494             : {
    4495           1 :     OGRCurvePolygon cp;
    4496             :     OGRGeometry *ring;
    4497             : 
    4498             :     // closed CircularString
    4499           1 :     OGRGeometryFactory::createFromWkt(
    4500             :         "CIRCULARSTRING (0 0, 1 1, 2 0, 1 -1, 0 0)", nullptr, &ring);
    4501           1 :     ASSERT_TRUE(ring);
    4502           1 :     EXPECT_EQ(cp.addRingDirectly(ring->toCurve()), OGRERR_NONE);
    4503             : 
    4504             :     // open CircularString
    4505           1 :     OGRGeometryFactory::createFromWkt("CIRCULARSTRING (0 0, 1 1, 2 0)", nullptr,
    4506             :                                       &ring);
    4507           1 :     ASSERT_TRUE(ring);
    4508             :     {
    4509             :         CPLConfigOptionSetter oSetter("OGR_GEOMETRY_ACCEPT_UNCLOSED_RING", "NO",
    4510           1 :                                       false);
    4511           1 :         ASSERT_EQ(cp.addRingDirectly(ring->toCurve()),
    4512             :                   OGRERR_UNSUPPORTED_GEOMETRY_TYPE);
    4513             :     }
    4514           1 :     EXPECT_EQ(cp.addRingDirectly(ring->toCurve()), OGRERR_NONE);
    4515             : 
    4516             :     // closed CompoundCurve
    4517           1 :     OGRGeometryFactory::createFromWkt(
    4518             :         "COMPOUNDCURVE( CIRCULARSTRING (0 0, 1 1, 2 0), (2 0, 0 0))", nullptr,
    4519             :         &ring);
    4520           1 :     ASSERT_TRUE(ring);
    4521           1 :     EXPECT_EQ(cp.addRingDirectly(ring->toCurve()), OGRERR_NONE);
    4522             : 
    4523             :     // closed LineString
    4524           1 :     OGRGeometryFactory::createFromWkt("LINESTRING (0 0, 1 0, 1 1, 0 1, 0 0)",
    4525             :                                       nullptr, &ring);
    4526           1 :     ASSERT_TRUE(ring);
    4527           1 :     EXPECT_EQ(cp.addRingDirectly(ring->toCurve()), OGRERR_NONE);
    4528             : 
    4529             :     // LinearRing
    4530           1 :     auto lr = std::make_unique<OGRLinearRing>();
    4531           1 :     lr->addPoint(0, 0);
    4532           1 :     lr->addPoint(1, 0);
    4533           1 :     lr->addPoint(1, 1);
    4534           1 :     lr->addPoint(0, 1);
    4535           1 :     lr->addPoint(0, 0);
    4536           1 :     ASSERT_TRUE(ring);
    4537           1 :     ASSERT_EQ(cp.addRingDirectly(lr.get()), OGRERR_UNSUPPORTED_GEOMETRY_TYPE);
    4538             : }
    4539             : 
    4540             : // Test OGRPolygon::addRingDirectly
    4541           4 : TEST_F(test_ogr, OGRPolygon_addRingDirectly)
    4542             : {
    4543           1 :     OGRPolygon p;
    4544             :     OGRGeometry *ring;
    4545             : 
    4546             :     // closed CircularString
    4547           1 :     OGRGeometryFactory::createFromWkt(
    4548             :         "CIRCULARSTRING (0 0, 1 1, 2 0, 1 -1, 0 0)", nullptr, &ring);
    4549           1 :     ASSERT_TRUE(ring);
    4550           1 :     EXPECT_EQ(p.addRingDirectly(ring->toCurve()),
    4551             :               OGRERR_UNSUPPORTED_GEOMETRY_TYPE);
    4552           1 :     delete ring;
    4553             : 
    4554             :     // closed LineString
    4555           1 :     OGRGeometryFactory::createFromWkt("LINESTRING (0 0, 1 0, 1 1, 0 1, 0 0)",
    4556             :                                       nullptr, &ring);
    4557           1 :     ASSERT_TRUE(ring);
    4558           1 :     EXPECT_EQ(p.addRingDirectly(ring->toCurve()),
    4559             :               OGRERR_UNSUPPORTED_GEOMETRY_TYPE);
    4560           1 :     delete ring;
    4561             : 
    4562             :     // open LineString
    4563           1 :     OGRGeometryFactory::createFromWkt("LINESTRING (0 0, 1 0)", nullptr, &ring);
    4564           1 :     ASSERT_TRUE(ring);
    4565           1 :     EXPECT_EQ(p.addRingDirectly(ring->toCurve()),
    4566             :               OGRERR_UNSUPPORTED_GEOMETRY_TYPE);
    4567           1 :     delete ring;
    4568             : 
    4569             :     // LinearRing
    4570           1 :     auto lr = std::make_unique<OGRLinearRing>();
    4571           1 :     lr->addPoint(0, 0);
    4572           1 :     lr->addPoint(1, 0);
    4573           1 :     lr->addPoint(1, 1);
    4574           1 :     lr->addPoint(0, 1);
    4575           1 :     lr->addPoint(0, 0);
    4576           1 :     ASSERT_EQ(p.addRingDirectly(lr.release()), OGRERR_NONE);
    4577             : }
    4578             : 
    4579           4 : TEST_F(test_ogr, OGRFeature_SetGeometry)
    4580             : {
    4581           1 :     OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn();
    4582           1 :     poFeatureDefn->Reference();
    4583             : 
    4584           1 :     OGRFeature oFeat(poFeatureDefn);
    4585           1 :     auto [poGeom, err] = OGRGeometryFactory::createFromWkt("POINT (3 7)");
    4586           1 :     ASSERT_EQ(err, OGRERR_NONE);
    4587             : 
    4588           1 :     ASSERT_EQ(oFeat.SetGeometry(std::move(poGeom)), OGRERR_NONE);
    4589           1 :     EXPECT_EQ(oFeat.GetGeometryRef()->toPoint()->getX(), 3);
    4590           1 :     EXPECT_EQ(oFeat.GetGeometryRef()->toPoint()->getY(), 7);
    4591             : 
    4592             :     // set it again to make sure previous feature geometry is freed
    4593           1 :     std::tie(poGeom, err) = OGRGeometryFactory::createFromWkt("POINT (2 8)");
    4594           1 :     ASSERT_EQ(err, OGRERR_NONE);
    4595           1 :     ASSERT_EQ(oFeat.SetGeometry(std::move(poGeom)), OGRERR_NONE);
    4596           1 :     EXPECT_EQ(oFeat.GetGeometryRef()->toPoint()->getX(), 2);
    4597           1 :     EXPECT_EQ(oFeat.GetGeometryRef()->toPoint()->getY(), 8);
    4598             : 
    4599           1 :     poFeatureDefn->Release();
    4600             : }
    4601             : 
    4602           4 : TEST_F(test_ogr, OGRFeature_SetGeomField)
    4603             : {
    4604           1 :     OGRFeatureDefn *poFeatureDefn = new OGRFeatureDefn();
    4605           1 :     poFeatureDefn->Reference();
    4606             : 
    4607           1 :     OGRGeomFieldDefn oGeomField("second", wkbPoint);
    4608           1 :     poFeatureDefn->AddGeomFieldDefn(&oGeomField);
    4609             : 
    4610           1 :     OGRFeature oFeat(poFeatureDefn);
    4611             : 
    4612             :     // failure
    4613             :     {
    4614           1 :         auto [poGeom, err] = OGRGeometryFactory::createFromWkt("POINT (3 7)");
    4615           1 :         ASSERT_EQ(err, OGRERR_NONE);
    4616           1 :         EXPECT_EQ(oFeat.SetGeomField(13, std::move(poGeom)), OGRERR_FAILURE);
    4617             :     }
    4618             : 
    4619             :     // success
    4620             :     {
    4621           1 :         auto [poGeom, err] = OGRGeometryFactory::createFromWkt("POINT (3 7)");
    4622           1 :         ASSERT_EQ(err, OGRERR_NONE);
    4623           1 :         EXPECT_EQ(oFeat.SetGeomField(1, std::move(poGeom)), OGRERR_NONE);
    4624             :     }
    4625             : 
    4626           1 :     poFeatureDefn->Release();
    4627             : }
    4628             : 
    4629           4 : TEST_F(test_ogr, GetArrowStream_DateTime_As_String)
    4630             : {
    4631             :     auto poDS = std::unique_ptr<GDALDataset>(
    4632             :         GetGDALDriverManager()->GetDriverByName("MEM")->Create(
    4633           1 :             "", 0, 0, 0, GDT_Unknown, nullptr));
    4634           1 :     auto poLayer = poDS->CreateLayer("test", nullptr, wkbNone);
    4635           1 :     OGRFieldDefn oFieldDefn("dt", OFTDateTime);
    4636           1 :     poLayer->CreateField(&oFieldDefn);
    4637             :     struct ArrowArrayStream stream;
    4638           1 :     CPLStringList aosOptions;
    4639           1 :     aosOptions.SetNameValue("INCLUDE_FID", "NO");
    4640           1 :     aosOptions.SetNameValue("DATETIME_AS_STRING", "YES");
    4641           1 :     ASSERT_TRUE(poLayer->GetArrowStream(&stream, aosOptions.List()));
    4642             :     struct ArrowSchema schema;
    4643           1 :     memset(&schema, 0, sizeof(schema));
    4644           1 :     EXPECT_EQ(stream.get_schema(&stream, &schema), 0);
    4645           1 :     EXPECT_TRUE(schema.n_children == 1 &&
    4646             :                 strcmp(schema.children[0]->format, "u") == 0)
    4647           0 :         << schema.n_children;
    4648           1 :     if (schema.n_children == 1 && strcmp(schema.children[0]->format, "u") == 0)
    4649             :     {
    4650           1 :         EXPECT_TRUE(schema.children[0]->metadata != nullptr);
    4651           1 :         if (schema.children[0]->metadata)
    4652             :         {
    4653             :             auto oMapKeyValue =
    4654           2 :                 OGRParseArrowMetadata(schema.children[0]->metadata);
    4655           1 :             EXPECT_EQ(oMapKeyValue.size(), 1);
    4656           1 :             if (oMapKeyValue.size() == 1)
    4657             :             {
    4658           1 :                 EXPECT_STREQ(oMapKeyValue.begin()->first.c_str(),
    4659             :                              "GDAL:OGR:type");
    4660           1 :                 EXPECT_STREQ(oMapKeyValue.begin()->second.c_str(), "DateTime");
    4661             :             }
    4662             :         }
    4663             :     }
    4664           1 :     schema.release(&schema);
    4665           1 :     stream.release(&stream);
    4666             : }
    4667             : 
    4668             : // Test OGRFeatureDefn::GetFieldSubTypeByName()
    4669           4 : TEST_F(test_ogr, OGRFieldDefnGetFieldSubTypeByName)
    4670             : {
    4671           6 :     for (int i = 0; i < OFSTMaxSubType; i++)
    4672             :     {
    4673             :         const char *pszName =
    4674           5 :             OGRFieldDefn::GetFieldSubTypeName(static_cast<OGRFieldSubType>(i));
    4675           5 :         if (pszName != nullptr)
    4676             :         {
    4677           5 :             EXPECT_EQ(OGRFieldDefn::GetFieldSubTypeByName(pszName), i);
    4678             :         }
    4679             :     }
    4680           1 : }
    4681             : 
    4682             : // Test OGRFeatureDefn::GetFieldTypeByName()
    4683           4 : TEST_F(test_ogr, OGRFieldDefnGetFieldTypeByName)
    4684             : {
    4685          14 :     for (int i = 0; i < OFTMaxType; i++)
    4686             :     {
    4687             :         // deprecated types
    4688          13 :         if (i == OFTWideString || i == OFTWideStringList)
    4689             :         {
    4690           2 :             continue;
    4691             :         }
    4692             :         const char *pszName =
    4693          11 :             OGRFieldDefn::GetFieldTypeName(static_cast<OGRFieldType>(i));
    4694          11 :         if (pszName != nullptr)
    4695             :         {
    4696          11 :             EXPECT_EQ(OGRFieldDefn::GetFieldTypeByName(pszName), i);
    4697             :         }
    4698             :     }
    4699           1 : }
    4700             : 
    4701             : // Test OGRGeometryFactory::GetDefaultArcStepSize()
    4702           4 : TEST_F(test_ogr, GetDefaultArcStepSize)
    4703             : {
    4704           1 :     if (CPLGetConfigOption("OGR_ARC_STEPSIZE", nullptr) == nullptr)
    4705             :     {
    4706           1 :         EXPECT_EQ(OGRGeometryFactory::GetDefaultArcStepSize(), 4.0);
    4707             :     }
    4708             :     {
    4709             :         CPLConfigOptionSetter oSetter("OGR_ARC_STEPSIZE", "0.00001",
    4710           2 :                                       /* bSetOnlyIfUndefined = */ false);
    4711           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4712           1 :         EXPECT_EQ(OGRGeometryFactory::GetDefaultArcStepSize(), 1e-2);
    4713           1 :         EXPECT_TRUE(
    4714             :             strstr(CPLGetLastErrorMsg(),
    4715             :                    "Too small value for OGR_ARC_STEPSIZE. Clamping it to"));
    4716             :     }
    4717             :     {
    4718             :         CPLConfigOptionSetter oSetter("OGR_ARC_STEPSIZE", "190",
    4719           2 :                                       /* bSetOnlyIfUndefined = */ false);
    4720           2 :         CPLErrorHandlerPusher oErrorHandler(CPLQuietErrorHandler);
    4721           1 :         EXPECT_EQ(OGRGeometryFactory::GetDefaultArcStepSize(), 180);
    4722           1 :         EXPECT_TRUE(
    4723             :             strstr(CPLGetLastErrorMsg(),
    4724             :                    "Too large value for OGR_ARC_STEPSIZE. Clamping it to"));
    4725             :     }
    4726           1 : }
    4727             : 
    4728           4 : TEST_F(test_ogr, OGRPolygon_two_vertex_constructor)
    4729             : {
    4730           2 :     OGRPolygon p(1, 2, 3, 4);
    4731           1 :     char *outWKT = nullptr;
    4732           1 :     p.exportToWkt(&outWKT, wkbVariantIso);
    4733           1 :     EXPECT_STREQ(outWKT, "POLYGON ((1 2,1 4,3 4,3 2,1 2))");
    4734           1 :     CPLFree(outWKT);
    4735           1 : }
    4736             : 
    4737             : }  // namespace

Generated by: LCOV version 1.14