no message

martin-georgiev · martin-georgiev · commit 21954544e739 · 2025-08-27T16:40:54.000+03:00
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BoundingBoxDistanceTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BoundingBoxDistanceTest.php
@@ -17,53 +17,48 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function bounding_box_distance_returns_zero_for_identical_geometries(): void
+    public function returns_zero_when_comparing_identical_point_geometries(): void
     {
-        // Identical geometries have zero bounding box distance
         $dql = "SELECT BOUNDING_BOX_DISTANCE('POINT(1 1)', 'POINT(1 1)') as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertEquals(0, $result[0]['distance'], 'Bounding box distance for identical geometries should be 0');
+        $this->assertEquals(0, $result[0]['distance']);
     }
 
     #[Test]
-    public function bounding_box_distance_returns_zero_for_overlapping_bounding_boxes(): void
+    public function returns_zero_when_polygon_bounding_boxes_overlap(): void
     {
-        // Overlapping polygons have zero bounding box distance
         $dql = "SELECT BOUNDING_BOX_DISTANCE('POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))', 'POLYGON((1 1, 3 1, 3 3, 1 3, 1 1))') as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertEquals(0, $result[0]['distance'], 'Overlapping bounding boxes should have distance 0');
+        $this->assertEquals(0, $result[0]['distance']);
     }
 
     #[Test]
-    public function bounding_box_distance_returns_correct_distance_for_separated_geometries(): void
+    public function can_calculate_euclidean_distance_between_separated_points(): void
     {
-        // Distance between separated points
         $dql = "SELECT BOUNDING_BOX_DISTANCE('POINT(0 0)', 'POINT(3 4)') as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertEquals(5.0, $result[0]['distance'], 'Bounding box distance between (0,0) and (3,4) should be 5');
+        $this->assertEquals(5.0, $result[0]['distance']);
     }
 
     #[Test]
-    public function bounding_box_distance_with_separated_polygons(): void
+    public function can_calculate_distance_between_non_overlapping_polygons(): void
     {
-        // Distance between non-overlapping polygons
         $dql = "SELECT BOUNDING_BOX_DISTANCE('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))', 'POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))') as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
         $this->assertIsNumeric($result[0]['distance']);
         $this->assertGreaterThan(0, $result[0]['distance']);
-        // Distance should be approximately sqrt((3-1)² + (3-1)²) = sqrt(8) ≈ 2.83
-        $this->assertEqualsWithDelta(2.83, $result[0]['distance'], 0.1, 'Distance between separated polygons');
+        $this->assertEqualsWithDelta(2.83, $result[0]['distance'], 0.1, 'Distance should be approximately sqrt((3-1)² + (3-1)²) = sqrt(8) ≈ 2.83 between separated polygon bounding boxes');
     }
 }
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/GeometryDistanceTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/GeometryDistanceTest.php
@@ -17,7 +17,7 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function geometry_distance_with_geometrical_types(): void
+    public function can_calculate_euclidean_distance_between_geometric_points(): void
     {
         $dql = 'SELECT GEOMETRY_DISTANCE(g.geometry1, g.geometry2) as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
@@ -26,29 +26,29 @@ public function geometry_distance_with_geometrical_types(): void
         $result = $this->executeDqlQuery($dql);
         $this->assertIsNumeric($result[0]['distance']);
         $this->assertGreaterThan(0, $result[0]['distance']);
-        $this->assertEqualsWithDelta(1.414, $result[0]['distance'], 0.01, 'Distance between (0,0) and (1,1) should be sqrt(2) ≈ 1.414');
+        $this->assertEqualsWithDelta(1.414, $result[0]['distance'], 0.01, 'Euclidean distance between points (0,0) and (1,1) should be sqrt(2) ≈ 1.414');
     }
 
     #[Test]
-    public function geometry_distance_returns_zero_for_identical_geometries(): void
+    public function returns_zero_when_comparing_identical_geometries(): void
     {
         $dql = 'SELECT GEOMETRY_DISTANCE(g.geometry1, g.geometry1) as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1';
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertEquals(0, $result[0]['distance'], 'Distance between identical geometries should be 0');
+        $this->assertEquals(0, $result[0]['distance']);
     }
 
     #[Test]
-    public function geometry_distance_with_geographical_types(): void
+    public function can_calculate_spherical_distance_between_geographical_coordinates(): void
     {
         $dql = 'SELECT GEOMETRY_DISTANCE(g.geography1, g.geography2) as distance
                 FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1';
 
         $result = $this->executeDqlQuery($dql);
         $this->assertIsNumeric($result[0]['distance']);
-        $this->assertGreaterThan(1000000, $result[0]['distance'], 'Lisbon to London is > 1M meters');
+        $this->assertGreaterThan(1000000, $result[0]['distance'], 'Spherical distance between Lisbon and London geographical coordinates should be greater than 1 million meters');
     }
 }
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/LnTest.php
@@ -17,15 +17,15 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function ln(): void
+    public function can_calculate_natural_logarithm_of_euler_constant(): void
     {
         $dql = 'SELECT LN(2.718281828459) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1';
         $result = $this->executeDqlQuery($dql);
         $this->assertEqualsWithDelta(1.0, $result[0]['result'], 0.0001);
     }
 
     #[Test]
-    public function ln_with_entity_property(): void
+    public function can_calculate_natural_logarithm_of_entity_decimal_value(): void
     {
         $dql = 'SELECT LN(n.decimal1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';
         $result = $this->executeDqlQuery($dql);
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NDimensionalCentroidDistanceTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NDimensionalCentroidDistanceTest.php
@@ -17,10 +17,10 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function nd_centroid_distance_with_geometries(): void
+    public function can_calculate_distance_between_geometry_centroids(): void
     {
-        $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry2) as distance 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry2) as distance
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1';
 
         $result = $this->executeDqlQuery($dql);
@@ -29,10 +29,10 @@ public function nd_centroid_distance_with_geometries(): void
     }
 
     #[Test]
-    public function nd_centroid_distance_with_literal_geometry(): void
+    public function can_calculate_distance_between_geometry_and_literal_point(): void
     {
-        $dql = "SELECT ND_CENTROID_DISTANCE(g.geometry1, 'POINT(3 3)') as distance 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = "SELECT ND_CENTROID_DISTANCE(g.geometry1, 'POINT(3 3)') as distance
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
@@ -41,10 +41,10 @@ public function nd_centroid_distance_with_literal_geometry(): void
     }
 
     #[Test]
-    public function nd_centroid_distance_with_identical_geometries(): void
+    public function returns_zero_when_comparing_identical_geometries(): void
     {
-        $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry1) as distance 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry1) as distance
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1';
 
         $result = $this->executeDqlQuery($dql);
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NDimensionalOverlapsTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/NDimensionalOverlapsTest.php
@@ -17,21 +17,21 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function nd_overlaps_with_2d_geometries(): void
+    public function returns_true_when_2d_polygons_have_overlapping_bounding_boxes(): void
     {
-        $dql = 'SELECT ND_OVERLAPS(g.geometry1, g.geometry2) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT ND_OVERLAPS(g.geometry1, g.geometry2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 2';
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertTrue($result[0]['result'], 'Overlapping polygons should return true for n-dimensional overlaps');
+        $this->assertTrue($result[0]['result']);
     }
 
     #[Test]
-    public function nd_overlaps_with_identical_geometries(): void
+    public function returns_true_when_comparing_identical_geometries(): void
     {
-        $dql = 'SELECT ND_OVERLAPS(g.geometry1, g.geometry1) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT ND_OVERLAPS(g.geometry1, g.geometry1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1';
 
         $result = $this->executeDqlQuery($dql);
diff --git a/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/OverlapsAboveTest.php b/tests/Integration/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/OverlapsAboveTest.php
@@ -17,35 +17,35 @@ protected function getStringFunctions(): array
     }
 
     #[Test]
-    public function overlaps_above_with_geometries(): void
+    public function returns_false_when_polygons_are_at_same_vertical_level(): void
     {
-        $dql = 'SELECT OVERLAPS_ABOVE(g.geometry1, g.geometry2) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT OVERLAPS_ABOVE(g.geometry1, g.geometry2) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 2';
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertFalse($result[0]['result'], 'Overlapping polygons may not be considered above each other');
+        $this->assertFalse($result[0]['result']);
     }
 
     #[Test]
-    public function overlaps_above_with_literal_geometry(): void
+    public function returns_true_when_geometry_is_positioned_above_literal_point(): void
     {
-        $dql = "SELECT OVERLAPS_ABOVE(g.geometry1, 'POINT(0 -1)') as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = "SELECT OVERLAPS_ABOVE(g.geometry1, 'POINT(0 -1)') as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 1";
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertTrue($result[0]['result'], 'Overlapping or above geometries should return true');
+        $this->assertTrue($result[0]['result']);
     }
 
     #[Test]
-    public function overlaps_above_with_polygons(): void
+    public function returns_true_when_second_polygon_overlaps_or_is_above_first(): void
     {
-        $dql = 'SELECT OVERLAPS_ABOVE(g.geometry2, g.geometry1) as result 
-                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g 
+        $dql = 'SELECT OVERLAPS_ABOVE(g.geometry2, g.geometry1) as result
+                FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g
                 WHERE g.id = 2';
 
         $result = $this->executeDqlQuery($dql);
-        $this->assertTrue($result[0]['result'], 'Overlapping or above geometries should return true');
+        $this->assertTrue($result[0]['result']);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -17,53 +17,48 @@ protected function getStringFunctions(): array`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[Test]`
`20`		`- public function bounding_box_distance_returns_zero_for_identical_geometries(): void`
	`20`	`+ public function returns_zero_when_comparing_identical_point_geometries(): void`
`21`	`21`	`{`
`22`		`- // Identical geometries have zero bounding box distance`
`23`	`22`	`$dql = "SELECT BOUNDING_BOX_DISTANCE('POINT(1 1)', 'POINT(1 1)') as distance`
`24`	`23`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`25`	`24`	`WHERE g.id = 1";`
`26`	`25`
`27`	`26`	`$result = $this->executeDqlQuery($dql);`
`28`		`- $this->assertEquals(0, $result[0]['distance'], 'Bounding box distance for identical geometries should be 0');`
	`27`	`+ $this->assertEquals(0, $result[0]['distance']);`
`29`	`28`	`}`
`30`	`29`
`31`	`30`	`#[Test]`
`32`		`- public function bounding_box_distance_returns_zero_for_overlapping_bounding_boxes(): void`
	`31`	`+ public function returns_zero_when_polygon_bounding_boxes_overlap(): void`
`33`	`32`	`{`
`34`		`- // Overlapping polygons have zero bounding box distance`
`35`	`33`	`$dql = "SELECT BOUNDING_BOX_DISTANCE('POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))', 'POLYGON((1 1, 3 1, 3 3, 1 3, 1 1))') as distance`
`36`	`34`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`37`	`35`	`WHERE g.id = 1";`
`38`	`36`
`39`	`37`	`$result = $this->executeDqlQuery($dql);`
`40`		`- $this->assertEquals(0, $result[0]['distance'], 'Overlapping bounding boxes should have distance 0');`
	`38`	`+ $this->assertEquals(0, $result[0]['distance']);`
`41`	`39`	`}`
`42`	`40`
`43`	`41`	`#[Test]`
`44`		`- public function bounding_box_distance_returns_correct_distance_for_separated_geometries(): void`
	`42`	`+ public function can_calculate_euclidean_distance_between_separated_points(): void`
`45`	`43`	`{`
`46`		`- // Distance between separated points`
`47`	`44`	`$dql = "SELECT BOUNDING_BOX_DISTANCE('POINT(0 0)', 'POINT(3 4)') as distance`
`48`	`45`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`49`	`46`	`WHERE g.id = 1";`
`50`	`47`
`51`	`48`	`$result = $this->executeDqlQuery($dql);`
`52`		`- $this->assertEquals(5.0, $result[0]['distance'], 'Bounding box distance between (0,0) and (3,4) should be 5');`
	`49`	`+ $this->assertEquals(5.0, $result[0]['distance']);`
`53`	`50`	`}`
`54`	`51`
`55`	`52`	`#[Test]`
`56`		`- public function bounding_box_distance_with_separated_polygons(): void`
	`53`	`+ public function can_calculate_distance_between_non_overlapping_polygons(): void`
`57`	`54`	`{`
`58`		`- // Distance between non-overlapping polygons`
`59`	`55`	`$dql = "SELECT BOUNDING_BOX_DISTANCE('POLYGON((0 0, 1 0, 1 1, 0 1, 0 0))', 'POLYGON((3 3, 4 3, 4 4, 3 4, 3 3))') as distance`
`60`	`56`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`61`	`57`	`WHERE g.id = 1";`
`62`	`58`
`63`	`59`	`$result = $this->executeDqlQuery($dql);`
`64`	`60`	`$this->assertIsNumeric($result[0]['distance']);`
`65`	`61`	`$this->assertGreaterThan(0, $result[0]['distance']);`
`66`		`- // Distance should be approximately sqrt((3-1)² + (3-1)²) = sqrt(8) ≈ 2.83`
`67`		`- $this->assertEqualsWithDelta(2.83, $result[0]['distance'], 0.1, 'Distance between separated polygons');`
	`62`	`+ $this->assertEqualsWithDelta(2.83, $result[0]['distance'], 0.1, 'Distance should be approximately sqrt((3-1)² + (3-1)²) = sqrt(8) ≈ 2.83 between separated polygon bounding boxes');`
`68`	`63`	`}`
`69`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ protected function getStringFunctions(): array`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[Test]`
`20`		`- public function geometry_distance_with_geometrical_types(): void`
	`20`	`+ public function can_calculate_euclidean_distance_between_geometric_points(): void`
`21`	`21`	`{`
`22`	`22`	`$dql = 'SELECT GEOMETRY_DISTANCE(g.geometry1, g.geometry2) as distance`
`23`	`23`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`@@ -26,29 +26,29 @@ public function geometry_distance_with_geometrical_types(): void`
`26`	`26`	`$result = $this->executeDqlQuery($dql);`
`27`	`27`	`$this->assertIsNumeric($result[0]['distance']);`
`28`	`28`	`$this->assertGreaterThan(0, $result[0]['distance']);`
`29`		`- $this->assertEqualsWithDelta(1.414, $result[0]['distance'], 0.01, 'Distance between (0,0) and (1,1) should be sqrt(2) ≈ 1.414');`
	`29`	`+ $this->assertEqualsWithDelta(1.414, $result[0]['distance'], 0.01, 'Euclidean distance between points (0,0) and (1,1) should be sqrt(2) ≈ 1.414');`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`#[Test]`
`33`		`- public function geometry_distance_returns_zero_for_identical_geometries(): void`
	`33`	`+ public function returns_zero_when_comparing_identical_geometries(): void`
`34`	`34`	`{`
`35`	`35`	`$dql = 'SELECT GEOMETRY_DISTANCE(g.geometry1, g.geometry1) as distance`
`36`	`36`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`37`	`37`	`WHERE g.id = 1';`
`38`	`38`
`39`	`39`	`$result = $this->executeDqlQuery($dql);`
`40`		`- $this->assertEquals(0, $result[0]['distance'], 'Distance between identical geometries should be 0');`
	`40`	`+ $this->assertEquals(0, $result[0]['distance']);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`#[Test]`
`44`		`- public function geometry_distance_with_geographical_types(): void`
	`44`	`+ public function can_calculate_spherical_distance_between_geographical_coordinates(): void`
`45`	`45`	`{`
`46`	`46`	`$dql = 'SELECT GEOMETRY_DISTANCE(g.geography1, g.geography2) as distance`
`47`	`47`	`FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`48`	`48`	`WHERE g.id = 1';`
`49`	`49`
`50`	`50`	`$result = $this->executeDqlQuery($dql);`
`51`	`51`	`$this->assertIsNumeric($result[0]['distance']);`
`52`		`- $this->assertGreaterThan(1000000, $result[0]['distance'], 'Lisbon to London is > 1M meters');`
	`52`	`+ $this->assertGreaterThan(1000000, $result[0]['distance'], 'Spherical distance between Lisbon and London geographical coordinates should be greater than 1 million meters');`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,15 +17,15 @@ protected function getStringFunctions(): array`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[Test]`
`20`		`- public function ln(): void`
	`20`	`+ public function can_calculate_natural_logarithm_of_euler_constant(): void`
`21`	`21`	`{`
`22`	`22`	`$dql = 'SELECT LN(2.718281828459) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics t WHERE t.id = 1';`
`23`	`23`	`$result = $this->executeDqlQuery($dql);`
`24`	`24`	`$this->assertEqualsWithDelta(1.0, $result[0]['result'], 0.0001);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`#[Test]`
`28`		`- public function ln_with_entity_property(): void`
	`28`	`+ public function can_calculate_natural_logarithm_of_entity_decimal_value(): void`
`29`	`29`	`{`
`30`	`30`	`$dql = 'SELECT LN(n.decimal1) as result FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsNumerics n WHERE n.id = 1';`
`31`	`31`	`$result = $this->executeDqlQuery($dql);`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,10 @@ protected function getStringFunctions(): array`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[Test]`
`20`		`- public function nd_centroid_distance_with_geometries(): void`
	`20`	`+ public function can_calculate_distance_between_geometry_centroids(): void`
`21`	`21`	`{`
`22`		`- $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry2) as distance`
`23`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`22`	`+ $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry2) as distance`
	`23`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`24`	`24`	`WHERE g.id = 1';`
`25`	`25`
`26`	`26`	`$result = $this->executeDqlQuery($dql);`
`@@ -29,10 +29,10 @@ public function nd_centroid_distance_with_geometries(): void`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`#[Test]`
`32`		`- public function nd_centroid_distance_with_literal_geometry(): void`
	`32`	`+ public function can_calculate_distance_between_geometry_and_literal_point(): void`
`33`	`33`	`{`
`34`		`- $dql = "SELECT ND_CENTROID_DISTANCE(g.geometry1, 'POINT(3 3)') as distance`
`35`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`34`	`+ $dql = "SELECT ND_CENTROID_DISTANCE(g.geometry1, 'POINT(3 3)') as distance`
	`35`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`36`	`36`	`WHERE g.id = 1";`
`37`	`37`
`38`	`38`	`$result = $this->executeDqlQuery($dql);`
`@@ -41,10 +41,10 @@ public function nd_centroid_distance_with_literal_geometry(): void`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`#[Test]`
`44`		`- public function nd_centroid_distance_with_identical_geometries(): void`
	`44`	`+ public function returns_zero_when_comparing_identical_geometries(): void`
`45`	`45`	`{`
`46`		`- $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry1) as distance`
`47`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`46`	`+ $dql = 'SELECT ND_CENTROID_DISTANCE(g.geometry1, g.geometry1) as distance`
	`47`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`48`	`48`	`WHERE g.id = 1';`
`49`	`49`
`50`	`50`	`$result = $this->executeDqlQuery($dql);`
Original file line number	Diff line number	Diff line change
`@@ -17,35 +17,35 @@ protected function getStringFunctions(): array`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`#[Test]`
`20`		`- public function overlaps_above_with_geometries(): void`
	`20`	`+ public function returns_false_when_polygons_are_at_same_vertical_level(): void`
`21`	`21`	`{`
`22`		`- $dql = 'SELECT OVERLAPS_ABOVE(g.geometry1, g.geometry2) as result`
`23`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`22`	`+ $dql = 'SELECT OVERLAPS_ABOVE(g.geometry1, g.geometry2) as result`
	`23`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`24`	`24`	`WHERE g.id = 2';`
`25`	`25`
`26`	`26`	`$result = $this->executeDqlQuery($dql);`
`27`		`- $this->assertFalse($result[0]['result'], 'Overlapping polygons may not be considered above each other');`
	`27`	`+ $this->assertFalse($result[0]['result']);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`#[Test]`
`31`		`- public function overlaps_above_with_literal_geometry(): void`
	`31`	`+ public function returns_true_when_geometry_is_positioned_above_literal_point(): void`
`32`	`32`	`{`
`33`		`- $dql = "SELECT OVERLAPS_ABOVE(g.geometry1, 'POINT(0 -1)') as result`
`34`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`33`	`+ $dql = "SELECT OVERLAPS_ABOVE(g.geometry1, 'POINT(0 -1)') as result`
	`34`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`35`	`35`	`WHERE g.id = 1";`
`36`	`36`
`37`	`37`	`$result = $this->executeDqlQuery($dql);`
`38`		`- $this->assertTrue($result[0]['result'], 'Overlapping or above geometries should return true');`
	`38`	`+ $this->assertTrue($result[0]['result']);`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`#[Test]`
`42`		`- public function overlaps_above_with_polygons(): void`
	`42`	`+ public function returns_true_when_second_polygon_overlaps_or_is_above_first(): void`
`43`	`43`	`{`
`44`		`- $dql = 'SELECT OVERLAPS_ABOVE(g.geometry2, g.geometry1) as result`
`45`		`- FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
	`44`	`+ $dql = 'SELECT OVERLAPS_ABOVE(g.geometry2, g.geometry1) as result`
	`45`	`+ FROM Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsGeometries g`
`46`	`46`	`WHERE g.id = 2';`
`47`	`47`
`48`	`48`	`$result = $this->executeDqlQuery($dql);`
`49`		`- $this->assertTrue($result[0]['result'], 'Overlapping or above geometries should return true');`
	`49`	`+ $this->assertTrue($result[0]['result']);`
`50`	`50`	`}`
`51`	`51`	`}`