[3.2.x] Fixed #32544 -- Confirmed support for GDAL 3.2 and GEOS 3.9.

Backport of e3cfba0029 from main.

tests/gis_tests/gdal_tests/test_geom.py

@@ -378,10 +378,10 @@ class OGRGeomTest(SimpleTestCase, TestDataMixin):
             b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
             d1 = OGRGeometry(self.geometries.diff_geoms[i].wkt)
             d2 = a.difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a - b)  # __sub__ is difference operator
+            self.assertTrue(d1.geos.equals(d2.geos))
+            self.assertTrue(d1.geos.equals((a - b).geos))  # __sub__ is difference operator
             a -= b  # testing __isub__
-            self.assertEqual(d1, a)
+            self.assertTrue(d1.geos.equals(a.geos))
 
     def test_intersection(self):
         "Testing intersects() and intersection()."
@@ -391,10 +391,10 @@ class OGRGeomTest(SimpleTestCase, TestDataMixin):
             i1 = OGRGeometry(self.geometries.intersect_geoms[i].wkt)
             self.assertTrue(a.intersects(b))
             i2 = a.intersection(b)
-            self.assertEqual(i1, i2)
-            self.assertEqual(i1, a & b)  # __and__ is intersection operator
+            self.assertTrue(i1.geos.equals(i2.geos))
+            self.assertTrue(i1.geos.equals((a & b).geos))  # __and__ is intersection operator
             a &= b  # testing __iand__
-            self.assertEqual(i1, a)
+            self.assertTrue(i1.geos.equals(a.geos))
 
     def test_symdifference(self):
         "Testing sym_difference()."
@@ -403,10 +403,10 @@ class OGRGeomTest(SimpleTestCase, TestDataMixin):
             b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
             d1 = OGRGeometry(self.geometries.sdiff_geoms[i].wkt)
             d2 = a.sym_difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a ^ b)  # __xor__ is symmetric difference operator
+            self.assertTrue(d1.geos.equals(d2.geos))
+            self.assertTrue(d1.geos.equals((a ^ b).geos))  # __xor__ is symmetric difference operator
             a ^= b  # testing __ixor__
-            self.assertEqual(d1, a)
+            self.assertTrue(d1.geos.equals(a.geos))
 
     def test_union(self):
         "Testing union()."
@@ -415,10 +415,10 @@ class OGRGeomTest(SimpleTestCase, TestDataMixin):
             b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
             u1 = OGRGeometry(self.geometries.union_geoms[i].wkt)
             u2 = a.union(b)
-            self.assertEqual(u1, u2)
-            self.assertEqual(u1, a | b)  # __or__ is union operator
+            self.assertTrue(u1.geos.equals(u2.geos))
+            self.assertTrue(u1.geos.equals((a | b).geos))  # __or__ is union operator
             a |= b  # testing __ior__
-            self.assertEqual(u1, a)
+            self.assertTrue(u1.geos.equals(a.geos))
 
     def test_add(self):
         "Testing GeometryCollection.add()."

tests/gis_tests/geoapp/test_functions.py

@@ -89,12 +89,22 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
         # MariaDB doesn't limit the number of decimals in bbox.
         if connection.ops.mariadb:
             chicago_json['bbox'] = [-87.650175, 41.850385, -87.650175, 41.850385]
-        self.assertJSONEqual(
-            City.objects.annotate(
-                geojson=functions.AsGeoJSON('point', bbox=True, crs=True, precision=5)
-            ).get(name='Chicago').geojson,
-            chicago_json,
-        )
+        try:
+            self.assertJSONEqual(
+                City.objects.annotate(
+                    geojson=functions.AsGeoJSON('point', bbox=True, crs=True, precision=5)
+                ).get(name='Chicago').geojson,
+                chicago_json,
+            )
+        except AssertionError:
+            # Give a second chance with different coords rounding.
+            chicago_json['coordinates'][1] = 41.85038
+            self.assertJSONEqual(
+                City.objects.annotate(
+                    geojson=functions.AsGeoJSON('point', bbox=True, crs=True, precision=5)
+                ).get(name='Chicago').geojson,
+                chicago_json,
+            )
 
     @skipUnlessDBFeature("has_AsGML_function")
     def test_asgml(self):
@@ -295,11 +305,10 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
         geom = Point(5, 23, srid=4326)
         qs = Country.objects.annotate(inter=functions.Intersection('mpoly', geom))
         for c in qs:
-            expected = (
-                None if connection.features.empty_intersection_returns_none
-                else c.mpoly.intersection(geom)
-            )
-            self.assertEqual(c.inter, expected)
+            if connection.features.empty_intersection_returns_none:
+                self.assertIsNone(c.inter)
+            else:
+                self.assertIs(c.inter.empty, True)
 
     @skipUnlessDBFeature("has_IsValid_function")
     def test_isvalid(self):
@@ -352,7 +361,7 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
         State.objects.create(name='invalid', poly=invalid_geom)
         invalid = State.objects.filter(name='invalid').annotate(repaired=functions.MakeValid('poly')).first()
         self.assertIs(invalid.repaired.valid, True)
-        self.assertEqual(invalid.repaired, fromstr('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))', srid=invalid.poly.srid))
+        self.assertTrue(invalid.repaired.equals(fromstr('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))', srid=invalid.poly.srid)))
 
     @skipUnlessDBFeature('has_MakeValid_function')
     def test_make_valid_multipolygon(self):
@@ -365,11 +374,11 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
             repaired=functions.MakeValid('poly'),
         ).get()
         self.assertIs(invalid.repaired.valid, True)
-        self.assertEqual(invalid.repaired, fromstr(
+        self.assertTrue(invalid.repaired.equals(fromstr(
             'MULTIPOLYGON (((0 0, 0 1, 1 1, 1 0, 0 0)), '
             '((10 0, 10 1, 11 1, 11 0, 10 0)))',
             srid=invalid.poly.srid,
-        ))
+        )))
         self.assertEqual(len(invalid.repaired), 2)
 
     @skipUnlessDBFeature('has_MakeValid_function')
@@ -528,14 +537,14 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
     def test_transform(self):
         # Pre-transformed points for Houston and Pueblo.
         ptown = fromstr('POINT(992363.390841912 481455.395105533)', srid=2774)
-        prec = 3  # Precision is low due to version variations in PROJ and GDAL.
 
         # Asserting the result of the transform operation with the values in
         #  the pre-transformed points.
         h = City.objects.annotate(pt=functions.Transform('point', ptown.srid)).get(name='Pueblo')
         self.assertEqual(2774, h.pt.srid)
-        self.assertAlmostEqual(ptown.x, h.pt.x, prec)
-        self.assertAlmostEqual(ptown.y, h.pt.y, prec)
+        # Precision is low due to version variations in PROJ and GDAL.
+        self.assertLess(ptown.x - h.pt.x, 1)
+        self.assertLess(ptown.y - h.pt.y, 1)
 
     @skipUnlessDBFeature("has_Translate_function")
     def test_translate(self):
@@ -569,11 +578,10 @@ class GISFunctionsTests(FuncTestMixin, TestCase):
             return
         for c in qs:
             self.assertTrue(c.mpoly.difference(geom).equals(c.difference))
-            expected_intersection = (
-                None if connection.features.empty_intersection_returns_none
-                else c.mpoly.intersection(geom)
-            )
-            self.assertEqual(c.intersection, expected_intersection)
+            if connection.features.empty_intersection_returns_none:
+                self.assertIsNone(c.intersection)
+            else:
+                self.assertIs(c.intersection.empty, True)
             self.assertTrue(c.mpoly.sym_difference(geom).equals(c.sym_difference))
             self.assertTrue(c.mpoly.union(geom).equals(c.union))
 

tests/gis_tests/geos_tests/test_geos.py

@@ -638,10 +638,10 @@ class GEOSTest(SimpleTestCase, TestDataMixin):
             i1 = fromstr(self.geometries.intersect_geoms[i].wkt)
             self.assertIs(a.intersects(b), True)
             i2 = a.intersection(b)
-            self.assertEqual(i1, i2)
-            self.assertEqual(i1, a & b)  # __and__ is intersection operator
+            self.assertTrue(i1.equals(i2))
+            self.assertTrue(i1.equals(a & b))  # __and__ is intersection operator
             a &= b  # testing __iand__
-            self.assertEqual(i1, a)
+            self.assertTrue(i1.equals(a))
 
     def test_union(self):
         "Testing union()."
@@ -650,10 +650,10 @@ class GEOSTest(SimpleTestCase, TestDataMixin):
             b = fromstr(self.geometries.topology_geoms[i].wkt_b)
             u1 = fromstr(self.geometries.union_geoms[i].wkt)
             u2 = a.union(b)
-            self.assertEqual(u1, u2)
-            self.assertEqual(u1, a | b)  # __or__ is union operator
+            self.assertTrue(u1.equals(u2))
+            self.assertTrue(u1.equals(a | b))  # __or__ is union operator
             a |= b  # testing __ior__
-            self.assertEqual(u1, a)
+            self.assertTrue(u1.equals(a))
 
     def test_unary_union(self):
         "Testing unary_union."
@@ -671,10 +671,10 @@ class GEOSTest(SimpleTestCase, TestDataMixin):
             b = fromstr(self.geometries.topology_geoms[i].wkt_b)
             d1 = fromstr(self.geometries.diff_geoms[i].wkt)
             d2 = a.difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a - b)  # __sub__ is difference operator
+            self.assertTrue(d1.equals(d2))
+            self.assertTrue(d1.equals(a - b))  # __sub__ is difference operator
             a -= b  # testing __isub__
-            self.assertEqual(d1, a)
+            self.assertTrue(d1.equals(a))
 
     def test_symdifference(self):
         "Testing sym_difference()."
@@ -683,10 +683,10 @@ class GEOSTest(SimpleTestCase, TestDataMixin):
             b = fromstr(self.geometries.topology_geoms[i].wkt_b)
             d1 = fromstr(self.geometries.sdiff_geoms[i].wkt)
             d2 = a.sym_difference(b)
-            self.assertEqual(d1, d2)
-            self.assertEqual(d1, a ^ b)  # __xor__ is symmetric difference operator
+            self.assertTrue(d1.equals(d2))
+            self.assertTrue(d1.equals(a ^ b))  # __xor__ is symmetric difference operator
             a ^= b  # testing __ixor__
-            self.assertEqual(d1, a)
+            self.assertTrue(d1.equals(a))
 
     def test_buffer(self):
         bg = self.geometries.buffer_geoms[0]