Restoring authorship annotation for <akhropov@yandex-team.ru>. Commit 2 of 2.

5 files changed, 159 insertions, 159 deletions

diff --git a/util/generic/guid.cpp b/util/generic/guid.cpp
index 51c17970a5..8b907457bc 100644
--- a/util/generic/guid.cpp
+++ b/util/generic/guid.cpp
@@ -71,8 +71,8 @@ TString GetGuidAsString(const TGUID& g) {
 
 TString CreateGuidAsString() {
     return TGUID::Create().AsGuidString();
-} 
- 
+}
+
 static bool GetDigit(const char c, ui32& digit) {
     digit = 0;
     if ('0' <= c && c <= '9') {
diff --git a/util/generic/maybe.h b/util/generic/maybe.h
index 54c43aaf59..34d21aebcd 100644
--- a/util/generic/maybe.h
+++ b/util/generic/maybe.h
@@ -378,8 +378,8 @@ public:
     }
 
     template <typename U>
-    TMaybe<U, Policy> Cast() const { 
-        return Defined() ? TMaybe<U, Policy>(*Data()) : TMaybe<U, Policy>(); 
+    TMaybe<U, Policy> Cast() const {
+        return Defined() ? TMaybe<U, Policy>(*Data()) : TMaybe<U, Policy>();
     }
 
     constexpr explicit operator bool() const noexcept {
@@ -451,9 +451,9 @@ private:
 template <class T>
 using TMaybeFail = TMaybe<T, NMaybe::TPolicyUndefinedFail>;
 
-template <class T, class TPolicy = ::NMaybe::TPolicyUndefinedExcept> 
-constexpr TMaybe<std::decay_t<T>, TPolicy> MakeMaybe(T&& value) { 
-    return TMaybe<std::decay_t<T>, TPolicy>(std::forward<T>(value)); 
+template <class T, class TPolicy = ::NMaybe::TPolicyUndefinedExcept>
+constexpr TMaybe<std::decay_t<T>, TPolicy> MakeMaybe(T&& value) {
+    return TMaybe<std::decay_t<T>, TPolicy>(std::forward<T>(value));
 }
 
 template <class T, class... TArgs>
@@ -466,26 +466,26 @@ constexpr TMaybe<T> MakeMaybe(std::initializer_list<U> il, TArgs&&... args) {
     return TMaybe<T>(typename TMaybe<T>::TInPlace{}, il, std::forward<TArgs>(args)...);
 }
 
-template <class T, class TPolicy> 
-void Swap(TMaybe<T, TPolicy>& lhs, TMaybe<T, TPolicy>& rhs) { 
+template <class T, class TPolicy>
+void Swap(TMaybe<T, TPolicy>& lhs, TMaybe<T, TPolicy>& rhs) {
     lhs.Swap(rhs);
 }
 
-template <class T, class TPolicy> 
-void swap(TMaybe<T, TPolicy>& lhs, TMaybe<T, TPolicy>& rhs) { 
+template <class T, class TPolicy>
+void swap(TMaybe<T, TPolicy>& lhs, TMaybe<T, TPolicy>& rhs) {
     lhs.Swap(rhs);
 }
 
-template <typename T, class TPolicy> 
-struct THash<TMaybe<T, TPolicy>> { 
-    constexpr size_t operator()(const TMaybe<T, TPolicy>& data) const { 
+template <typename T, class TPolicy>
+struct THash<TMaybe<T, TPolicy>> {
+    constexpr size_t operator()(const TMaybe<T, TPolicy>& data) const {
         return (data.Defined()) ? THash<T>()(data.GetRef()) : 42;
     }
 };
 
 // Comparisons between TMaybe
-template <class T, class TPolicy> 
-constexpr bool operator==(const ::TMaybe<T, TPolicy>& left, const ::TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator==(const ::TMaybe<T, TPolicy>& left, const ::TMaybe<T, TPolicy>& right) {
     return (static_cast<bool>(left) != static_cast<bool>(right))
                ? false
                : (
@@ -494,13 +494,13 @@ constexpr bool operator==(const ::TMaybe<T, TPolicy>& left, const ::TMaybe<T, TP
                          : *left == *right);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator!=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator!=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) {
     return !(left == right);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator<(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) {
     return (!static_cast<bool>(right))
                ? false
                : (
@@ -509,203 +509,203 @@ constexpr bool operator<(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy
                          : (*left < *right));
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator>(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) {
     return right < left;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator<=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) {
     return !(right < left);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) { 
+template <class T, class TPolicy>
+constexpr bool operator>=(const TMaybe<T, TPolicy>& left, const TMaybe<T, TPolicy>& right) {
     return !(left < right);
 }
 
 // Comparisons with TNothing
-template <class T, class TPolicy> 
-constexpr bool operator==(const TMaybe<T, TPolicy>& left, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator==(const TMaybe<T, TPolicy>& left, TNothing) noexcept {
     return !static_cast<bool>(left);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator==(TNothing, const TMaybe<T, TPolicy>& right) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator==(TNothing, const TMaybe<T, TPolicy>& right) noexcept {
     return !static_cast<bool>(right);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator!=(const TMaybe<T, TPolicy>& left, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator!=(const TMaybe<T, TPolicy>& left, TNothing) noexcept {
     return static_cast<bool>(left);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator!=(TNothing, const TMaybe<T, TPolicy>& right) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator!=(TNothing, const TMaybe<T, TPolicy>& right) noexcept {
     return static_cast<bool>(right);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<(const TMaybe<T, TPolicy>&, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator<(const TMaybe<T, TPolicy>&, TNothing) noexcept {
     return false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<(TNothing, const TMaybe<T, TPolicy>& right) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator<(TNothing, const TMaybe<T, TPolicy>& right) noexcept {
     return static_cast<bool>(right);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<=(const TMaybe<T, TPolicy>& left, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator<=(const TMaybe<T, TPolicy>& left, TNothing) noexcept {
     return !static_cast<bool>(left);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<=(TNothing, const TMaybe<T, TPolicy>&) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator<=(TNothing, const TMaybe<T, TPolicy>&) noexcept {
     return true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>(const TMaybe<T, TPolicy>& left, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator>(const TMaybe<T, TPolicy>& left, TNothing) noexcept {
     return static_cast<bool>(left);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>(TNothing, const TMaybe<T, TPolicy>&) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator>(TNothing, const TMaybe<T, TPolicy>&) noexcept {
     return false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>=(const TMaybe<T, TPolicy>&, TNothing) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator>=(const TMaybe<T, TPolicy>&, TNothing) noexcept {
     return true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>=(TNothing, const TMaybe<T, TPolicy>& right) noexcept { 
+template <class T, class TPolicy>
+constexpr bool operator>=(TNothing, const TMaybe<T, TPolicy>& right) noexcept {
     return !static_cast<bool>(right);
 }
 
 // Comparisons with T
 
-template <class T, class TPolicy> 
-constexpr bool operator==(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator==(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return static_cast<bool>(maybe) ? *maybe == value : false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator==(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator==(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? *maybe == value : false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator!=(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator!=(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return static_cast<bool>(maybe) ? !(*maybe == value) : true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator!=(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator!=(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? !(*maybe == value) : true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator<(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return static_cast<bool>(maybe) ? std::less<T>{}(*maybe, value) : true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator<(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? std::less<T>{}(value, *maybe) : false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<=(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator<=(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return !(maybe > value);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator<=(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator<=(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return !(value > maybe);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator>(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return static_cast<bool>(maybe) ? value < maybe : false;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator>(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? maybe < value : true;
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>=(const TMaybe<T, TPolicy>& maybe, const T& value) { 
+template <class T, class TPolicy>
+constexpr bool operator>=(const TMaybe<T, TPolicy>& maybe, const T& value) {
     return !(maybe < value);
 }
 
-template <class T, class TPolicy> 
-constexpr bool operator>=(const T& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy>
+constexpr bool operator>=(const T& value, const TMaybe<T, TPolicy>& maybe) {
     return !(value < maybe);
 }
 
 // Comparison with values convertible to T
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator==(const ::TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator==(const ::TMaybe<T, TPolicy>& maybe, const U& value) {
     return static_cast<bool>(maybe) ? *maybe == value : false;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator==(const U& value, const ::TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator==(const U& value, const ::TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? *maybe == value : false;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator!=(const TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator!=(const TMaybe<T, TPolicy>& maybe, const U& value) {
     return static_cast<bool>(maybe) ? !(*maybe == value) : true;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator!=(const U& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator!=(const U& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? !(*maybe == value) : true;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator<(const TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator<(const TMaybe<T, TPolicy>& maybe, const U& value) {
     return static_cast<bool>(maybe) ? std::less<T>{}(*maybe, value) : true;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator<(const U& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator<(const U& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? std::less<T>{}(value, *maybe) : false;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator<=(const TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator<=(const TMaybe<T, TPolicy>& maybe, const U& value) {
     return !(maybe > value);
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator<=(const U& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator<=(const U& value, const TMaybe<T, TPolicy>& maybe) {
     return !(value > maybe);
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator>(const TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator>(const TMaybe<T, TPolicy>& maybe, const U& value) {
     return static_cast<bool>(maybe) ? value < maybe : false;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator>(const U& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator>(const U& value, const TMaybe<T, TPolicy>& maybe) {
     return static_cast<bool>(maybe) ? maybe < value : true;
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator>=(const TMaybe<T, TPolicy>& maybe, const U& value) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator>=(const TMaybe<T, TPolicy>& maybe, const U& value) {
     return !(maybe < value);
 }
 
-template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0> 
-constexpr bool operator>=(const U& value, const TMaybe<T, TPolicy>& maybe) { 
+template <class T, class TPolicy, class U, std::enable_if_t<std::is_convertible<U, T>::value, int> = 0>
+constexpr bool operator>=(const U& value, const TMaybe<T, TPolicy>& maybe) {
     return !(value < maybe);
 }
 
diff --git a/util/generic/variant.h b/util/generic/variant.h
index 16b36cbfad..749fc75090 100644
--- a/util/generic/variant.h
+++ b/util/generic/variant.h
@@ -1,5 +1,5 @@
-#pragma once 
- 
+#pragma once
+
 #include "hash.h"
 
 #include <variant>
diff --git a/util/generic/ymath.h b/util/generic/ymath.h
index 4857b28566..9ff9ae2abe 100644
--- a/util/generic/ymath.h
+++ b/util/generic/ymath.h
@@ -172,35 +172,35 @@ inline bool FuzzyEquals(double p1, double p2, double eps = 1.0e-13) {
 inline bool FuzzyEquals(float p1, float p2, float eps = 1.0e-6) {
     return (Abs(p1 - p2) <= eps * Min(Abs(p1), Abs(p2)));
 }
- 
-namespace NUtilMathPrivate { 
-    template <bool IsSigned> 
-    struct TCeilDivImpl {}; 
- 
-    template <> 
-    struct TCeilDivImpl<true> { 
+
+namespace NUtilMathPrivate {
+    template <bool IsSigned>
+    struct TCeilDivImpl {};
+
+    template <>
+    struct TCeilDivImpl<true> {
         template <class T>
-        static inline T Do(T x, T y) noexcept { 
-            return x / y + (((x < 0) ^ (y > 0)) && (x % y)); 
-        } 
-    }; 
- 
-    template <> 
-    struct TCeilDivImpl<false> { 
+        static inline T Do(T x, T y) noexcept {
+            return x / y + (((x < 0) ^ (y > 0)) && (x % y));
+        }
+    };
+
+    template <>
+    struct TCeilDivImpl<false> {
         template <class T>
-        static inline T Do(T x, T y) noexcept { 
-            auto quot = x / y; 
-            return (x % y) ? (quot + 1) : quot; 
-        } 
-    }; 
-} 
- 
-/** 
- * @returns Equivalent to ceil((double) x / (double) y) but using only integer arithmetic operations 
- */ 
-template <class T> 
-inline T CeilDiv(T x, T y) noexcept { 
-    static_assert(std::is_integral<T>::value, "Integral type required."); 
-    Y_ASSERT(y != 0); 
-    return ::NUtilMathPrivate::TCeilDivImpl<std::is_signed<T>::value>::Do(x, y); 
-} 
+        static inline T Do(T x, T y) noexcept {
+            auto quot = x / y;
+            return (x % y) ? (quot + 1) : quot;
+        }
+    };
+}
+
+/**
+ * @returns Equivalent to ceil((double) x / (double) y) but using only integer arithmetic operations
+ */
+template <class T>
+inline T CeilDiv(T x, T y) noexcept {
+    static_assert(std::is_integral<T>::value, "Integral type required.");
+    Y_ASSERT(y != 0);
+    return ::NUtilMathPrivate::TCeilDivImpl<std::is_signed<T>::value>::Do(x, y);
+}
diff --git a/util/generic/ymath_ut.cpp b/util/generic/ymath_ut.cpp
index 15514e4bb3..29190b55eb 100644
--- a/util/generic/ymath_ut.cpp
+++ b/util/generic/ymath_ut.cpp
@@ -34,7 +34,7 @@ class TMathTest: public TTestBase {
     UNIT_TEST(TestAbs);
     UNIT_TEST(TestPower);
     UNIT_TEST(TestSigmoid);
-    UNIT_TEST(TestCeilDiv); 
+    UNIT_TEST(TestCeilDiv);
     UNIT_TEST_SUITE_END();
 
 private:
@@ -45,7 +45,7 @@ private:
     void TestAbs();
     void TestPower();
     void TestSigmoid();
-    void TestCeilDiv(); 
+    void TestCeilDiv();
 
     inline void TestIsValidFloat() {
         UNIT_ASSERT(IsValidFloat(-Max<double>() / 2.));
@@ -191,30 +191,30 @@ void TMathTest::TestSigmoid() {
     UNIT_ASSERT_EQUAL(Sigmoid(-5000.), 0.0);
     UNIT_ASSERT_EQUAL(Sigmoid(5000.), 1.0);
 }
- 
-void TMathTest::TestCeilDiv() { 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(2, 3), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(3, 3), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui32>(12, 2), 6); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui64>(10, 3), 4); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui64>(0, 10), 0); 
- 
-    // negative numbers 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(0, -10), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-1, 2), 0); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-1, -2), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(10, -5), -2); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-3, -4), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-6, -4), 2); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-6, 4), -1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-13, 4), -3); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-14, -4), 4); 
- 
-    // check values close to overflow 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(255, 10), 26); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui32>(std::numeric_limits<ui32>::max() - 3, std::numeric_limits<ui32>::max()), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i32>(std::numeric_limits<i32>::max() - 3, std::numeric_limits<i32>::max()), 1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i32>(std::numeric_limits<i32>::min(), std::numeric_limits<i32>::max()), -1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i8>(std::numeric_limits<i8>::max(), std::numeric_limits<i8>::min() + 1), -1); 
-    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i64>(std::numeric_limits<i64>::max() - 2, -(std::numeric_limits<i64>::min() + 1)), 1); 
-} 
+
+void TMathTest::TestCeilDiv() {
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(2, 3), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(3, 3), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui32>(12, 2), 6);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui64>(10, 3), 4);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui64>(0, 10), 0);
+
+    // negative numbers
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(0, -10), 0);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-1, 2), 0);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-1, -2), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(10, -5), -2);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-3, -4), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-6, -4), 2);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-6, 4), -1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-13, 4), -3);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv(-14, -4), 4);
+
+    // check values close to overflow
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui8>(255, 10), 26);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<ui32>(std::numeric_limits<ui32>::max() - 3, std::numeric_limits<ui32>::max()), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i32>(std::numeric_limits<i32>::max() - 3, std::numeric_limits<i32>::max()), 1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i32>(std::numeric_limits<i32>::min(), std::numeric_limits<i32>::max()), -1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i8>(std::numeric_limits<i8>::max(), std::numeric_limits<i8>::min() + 1), -1);
+    UNIT_ASSERT_VALUES_EQUAL(CeilDiv<i64>(std::numeric_limits<i64>::max() - 2, -(std::numeric_limits<i64>::min() + 1)), 1);
+}