1 files changed, 46 insertions, 46 deletions

diff --git a/coding/coding_tests/point_to_integer_test.cpp b/coding/coding_tests/point_to_integer_test.cpp
index 6b871818b4..d7322532d7 100644
--- a/coding/coding_tests/point_to_integer_test.cpp
+++ b/coding/coding_tests/point_to_integer_test.cpp
@@ -1,22 +1,25 @@
 #include "testing/testing.hpp"
 
 #include "coding/point_to_integer.hpp"
+#include "coding/pointd_to_pointu.hpp"
 
 #include "geometry/mercator.hpp"
 
 #include "base/logging.hpp"
 
-#include "std/cmath.hpp"
-#include "std/utility.hpp"
+#include <cmath>
+
+using namespace std;
 
 namespace
 {
-double const g_eps = MercatorBounds::GetCellID2PointAbsEpsilon();
-uint32_t const g_coordBits = POINT_COORD_BITS;
+double const kEps = MercatorBounds::GetCellID2PointAbsEpsilon();
+uint32_t const kCoordBits = POINT_COORD_BITS;
+uint32_t const kBig = uint32_t{1} << 30;
 
 void CheckEqualPoints(m2::PointD const & p1, m2::PointD const & p2)
 {
-  TEST(p1.EqualDxDy(p2, g_eps), (p1, p2));
+  TEST(p1.EqualDxDy(p2, kEps), (p1, p2));
 
   TEST_GREATER_OR_EQUAL(p1.x, -180.0, ());
   TEST_GREATER_OR_EQUAL(p1.y, -180.0, ());
@@ -28,34 +31,37 @@ void CheckEqualPoints(m2::PointD const & p1, m2::PointD const & p2)
   TEST_LESS_OR_EQUAL(p2.x, 180.0, ());
   TEST_LESS_OR_EQUAL(p2.y, 180.0, ());
 }
-}
+}  // namespace
 
-UNIT_TEST(PointToInt64_Smoke)
+UNIT_TEST(PointToInt64Obsolete_Smoke)
 {
   m2::PointD const arr[] = {{1.25, 1.3}, {180, 90}, {-180, -90}, {0, 0}};
 
   for (size_t i = 0; i < ARRAY_SIZE(arr); ++i)
-    CheckEqualPoints(arr[i], Int64ToPoint(PointToInt64(arr[i], g_coordBits), g_coordBits));
+    CheckEqualPoints(arr[i],
+                     Int64ToPointObsolete(PointToInt64Obsolete(arr[i], kCoordBits), kCoordBits));
 }
 
-UNIT_TEST(PointToInt64_Grid)
+UNIT_TEST(PointToInt64Obsolete_Grid)
 {
   int const delta = 5;
   for (int ix = -180; ix <= 180; ix += delta)
+  {
     for (int iy = -180; iy <= 180; iy += delta)
     {
       m2::PointD const pt(ix, iy);
-      int64_t const id = PointToInt64(pt, g_coordBits);
-      m2::PointD const pt1 = Int64ToPoint(id, g_coordBits);
+      int64_t const id = PointToInt64Obsolete(pt, kCoordBits);
+      m2::PointD const pt1 = Int64ToPointObsolete(id, kCoordBits);
 
       CheckEqualPoints(pt, pt1);
 
-      int64_t const id1 = PointToInt64(pt1, g_coordBits);
+      int64_t const id1 = PointToInt64Obsolete(pt1, kCoordBits);
       TEST_EQUAL(id, id1, (pt, pt1));
     }
+  }
 }
 
-UNIT_TEST(PointToInt64_Bounds)
+UNIT_TEST(PointToInt64Obsolete_Bounds)
 {
   double const arrEps[] = {-1.0E-2, -1.0E-3, -1.0E-4, 0, 1.0E-4, 1.0E-3, 1.0E-2};
 
@@ -63,50 +69,44 @@ UNIT_TEST(PointToInt64_Bounds)
                               {-90, -90}, {-90, 90},    {90, 90},    {90, -90}};
 
   for (size_t iP = 0; iP < ARRAY_SIZE(arrPt); ++iP)
+  {
     for (size_t iX = 0; iX < ARRAY_SIZE(arrEps); ++iX)
+    {
       for (size_t iY = 0; iY < ARRAY_SIZE(arrEps); ++iY)
       {
         m2::PointD const pt(arrPt[iP].x + arrEps[iX], arrPt[iP].y + arrEps[iY]);
-        m2::PointD const pt1 = Int64ToPoint(PointToInt64(pt, g_coordBits), g_coordBits);
+        m2::PointD const pt1 =
+            Int64ToPointObsolete(PointToInt64Obsolete(pt, kCoordBits), kCoordBits);
 
-        TEST(fabs(pt.x - pt1.x) <= (fabs(arrEps[iX]) + g_eps) &&
-                 fabs(pt.y - pt1.y) <= (fabs(arrEps[iY]) + g_eps),
+        TEST(fabs(pt.x - pt1.x) <= (fabs(arrEps[iX]) + kEps) &&
+                 fabs(pt.y - pt1.y) <= (fabs(arrEps[iY]) + kEps),
              (pt, pt1));
       }
+    }
+  }
 }
 
-UNIT_TEST(PointD2PointU_Epsilons)
+UNIT_TEST(PointUToUint64Obsolete_0)
 {
-  m2::PointD const arrPt[] = {{-180, -180}, {-180, 180}, {180, 180}, {180, -180}};
-  m2::PointD const arrD[] = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
-  size_t const count = ARRAY_SIZE(arrPt);
-
-  /*
-  double eps = 1.0;
-  for (; true; eps = eps / 10.0)
-  {
-    size_t i = 0;
-    for (; i < count; ++i)
-    {
-      m2::PointU p = PointD2PointU(arrPt[i].x, arrPt[i].y, g_coordBits);
-      m2::PointU p1 = PointD2PointU(arrPt[i].x + arrD[i].x * eps,
-                                    arrPt[i].y + arrD[i].y * eps,
-                                    g_coordBits);
-
-      if (p != p1) break;
-    }
-    if (i == count) break;
-  }
+  TEST_EQUAL(0, PointUToUint64Obsolete(m2::PointU(0, 0)), ());
+  TEST_EQUAL(m2::PointU(0, 0), Uint64ToPointUObsolete(0), ());
+}
 
-  LOG(LINFO, ("Epsilon = ", eps));
-  */
+UNIT_TEST(PointUToUint64Obsolete_Interlaced)
+{
+  TEST_EQUAL(0xAAAAAAAAAAAAAAAAULL, PointUToUint64Obsolete(m2::PointU(0, 0xFFFFFFFF)), ());
+  TEST_EQUAL(0x5555555555555555ULL, PointUToUint64Obsolete(m2::PointU(0xFFFFFFFF, 0)), ());
+  TEST_EQUAL(0xAAAAAAAAAAAAAAA8ULL, PointUToUint64Obsolete(m2::PointU(0, 0xFFFFFFFE)), ());
+  TEST_EQUAL(0x5555555555555554ULL, PointUToUint64Obsolete(m2::PointU(0xFFFFFFFE, 0)), ());
+}
 
-  for (size_t i = 0; i < count; ++i)
-  {
-    m2::PointU const p1 = PointD2PointU(arrPt[i].x, arrPt[i].y, g_coordBits);
-    m2::PointU const p2(p1.x + arrD[i].x, p1.y + arrD[i].y);
-    m2::PointD const p3 = PointU2PointD(p2, g_coordBits);
+UNIT_TEST(PointUToUint64Obsolete_1bit)
+{
+  TEST_EQUAL(2, PointUToUint64Obsolete(m2::PointU(0, 1)), ());
+  TEST_EQUAL(m2::PointU(0, 1), Uint64ToPointUObsolete(2), ());
+  TEST_EQUAL(1, PointUToUint64Obsolete(m2::PointU(1, 0)), ());
+  TEST_EQUAL(m2::PointU(1, 0), Uint64ToPointUObsolete(1), ());
 
-    LOG(LINFO, ("Dx = ", p3.x - arrPt[i].x, "Dy = ", p3.y - arrPt[i].y));
-  }
+  TEST_EQUAL(3ULL << 60, PointUToUint64Obsolete(m2::PointU(kBig, kBig)), ());
+  TEST_EQUAL((1ULL << 60) - 1, PointUToUint64Obsolete(m2::PointU(kBig - 1, kBig - 1)), ());
 }