Organic Maps sources as of 02.04.2025 (fad26bbf22ac3da75e01e62aa01e5c8e11861005)

To expand with full Organic Maps and Maps.ME commits history run:
  git remote add om-historic [om-historic.git repo url]
  git fetch --tags om-historic
  git replace squashed-history historic-commits

base/base_tests/exception_tests.cpp

@@ -0,0 +1,166 @@
+#include "testing/testing.hpp"
+
+#include "base/exception.hpp"
+
+#include <exception>
+#include <string>
+
+namespace
+{
+int FuncDoesNotThrow() noexcept { return 1; }
+int FuncThrowsRootException() { throw RootException("RootException", "RootException"); }
+int FuncThrowsException() { throw std::exception(); }
+int FuncThrowsRuntimeError() { throw std::runtime_error("runtime_error"); }
+int FuncThrowsNumber() { throw 1; };
+
+int FuncDoesNotThrowArg(int) noexcept { return 1; }
+int FuncThrowsRootExceptionArg(int) { throw RootException("RootException", "RootException"); }
+int FuncThrowsExceptionArg(int) { throw std::exception(); }
+int FuncThrowsNumberArg(int) { throw 1; };
+
+void FuncDoesNotThrowVoid(int) noexcept { return; }
+void FuncThrowsRootExceptionVoid(int) { throw RootException("RootException", "RootException"); }
+void FuncThrowsExceptionVoid() { throw std::exception(); }
+void FuncThrowsNumberVoid() { throw 1; };
+
+std::string const & ReturnsByRef(std::string const & str)
+{
+  bool exception = true;
+  return ExceptionCatcher(
+      "ReturnsByRef().", exception,
+      [](std::string const & str) -> std::string const & { return str; }, str);
+}
+
+UNIT_TEST(ExceptionCatcher_FunctionsWithoutArgs)
+{
+  bool exception = false;
+  ExceptionCatcher("Function without arg.", exception, FuncDoesNotThrow);
+  TEST(!exception, ());
+  ExceptionCatcher("Function without arg.", exception, FuncThrowsRootException);
+  TEST(exception, ());
+  ExceptionCatcher("Function without arg.", exception, FuncThrowsException);
+  TEST(exception, ());
+  ExceptionCatcher("Function without arg.", exception, FuncThrowsRuntimeError);
+  TEST(exception, ());
+  ExceptionCatcher("Function without arg.", exception, FuncThrowsNumber);
+  TEST(exception, ());
+}
+
+UNIT_TEST(ExceptionCatcher_Functions)
+{
+  bool exception = false;
+  ExceptionCatcher("Function with arg.", exception, FuncDoesNotThrowArg, 7);
+  TEST(!exception, ());
+  ExceptionCatcher("Function with arg.", exception, FuncThrowsRootExceptionArg, 7);
+  TEST(exception, ());
+  ExceptionCatcher("Function with arg.", exception, FuncThrowsExceptionArg, 7);
+  TEST(exception, ());
+  ExceptionCatcher("Function with arg.", exception, FuncThrowsNumberArg, 7);
+  TEST(exception, ());
+}
+
+UNIT_TEST(ExceptionCatcher_LambdasReturnInt)
+{
+  bool exception = false;
+  size_t callCount = 0;
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) {
+        ++callCount;
+        return 1;
+      },
+      7);
+  TEST(!exception, ());
+  TEST_EQUAL(callCount, 1, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) -> int {
+        ++callCount;
+        throw RootException("RootException", "RootException");
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 2, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) -> int {
+        ++callCount;
+        throw std::exception();
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 3, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) -> int {
+        ++callCount;
+        throw 1;
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 4, ());
+}
+
+UNIT_TEST(ExceptionCatcher_LambdasReturnVoid)
+{
+  bool exception = false;
+  size_t callCount = 0;
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) {
+        ++callCount;
+      },
+      7);
+  TEST(!exception, ());
+  TEST_EQUAL(callCount, 1, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) {
+        ++callCount;
+        throw RootException("RootException", "RootException");
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 2, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) {
+        ++callCount;
+        throw std::exception();
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 3, ());
+
+  ExceptionCatcher(
+      "Lambda", exception,
+      [&callCount](int) {
+        ++callCount;
+        throw 1;
+      },
+      7);
+  TEST(exception, ());
+  TEST_EQUAL(callCount, 4, ());
+}
+
+UNIT_TEST(ExceptionCatcher_FunctionsReturnVoid)
+{
+  bool exception = false;
+  ExceptionCatcher("Function returns void.", exception, FuncDoesNotThrowVoid, 7);
+  ExceptionCatcher("Function returns void.", exception, FuncThrowsRootExceptionVoid, 7);
+  ExceptionCatcher("Function returns void.", exception, FuncThrowsExceptionVoid);
+  ExceptionCatcher("Function returns void.", exception, FuncThrowsNumberVoid);
+}
+
+UNIT_TEST(ExceptionCatcher_PreventReturningRefOnLocalTemporaryObj)
+{
+  std::string const str = "A string";
+  auto const returnedStr = ReturnsByRef(str);
+  TEST_EQUAL(str, returnedStr, ());
+}
+}  // namespace