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

8 files changed, 674 insertions, 674 deletions

diff --git a/util/generic/strbase.h b/util/generic/strbase.h
index ab39fc7537..0af08e21a3 100644
--- a/util/generic/strbase.h
+++ b/util/generic/strbase.h
@@ -39,7 +39,7 @@ class TStringBase {
     using TStringView = std::basic_string_view<TCharType>;
     using TStringViewWithTraits = std::basic_string_view<TCharType, TTraitsType>;
 
-public:
+public: 
     using TChar = TCharType;
     using TTraits = TTraitsType;
     using TSelf = TStringBase<TDerived, TChar, TTraits>;
@@ -47,7 +47,7 @@ public:
     using size_type = size_t;
     using difference_type = ptrdiff_t;
     static constexpr size_t npos = size_t(-1);
-
+ 
     using const_iterator = const TCharType*;
     using const_reference = const TCharType&;
 
@@ -111,7 +111,7 @@ public:
             return TTraits::length(s);
         }
         return 0;
-    }
+    } 
 
     template <class TCharTraits>
     inline constexpr operator std::basic_string_view<TCharType, TCharTraits>() const {
@@ -121,27 +121,27 @@ public:
     template <class TCharTraits, class Allocator>
     inline explicit operator std::basic_string<TCharType, TCharTraits, Allocator>() const {
         return std::basic_string<TCharType, TCharTraits, Allocator>(Ptr(), Len());
-    }
+    } 
 
     /**
      * @param                           Pointer to character inside the string, or nullptr.
      * @return                          Offset from string beginning (in chars), or npos on nullptr.
      */
     inline size_t off(const TCharType* ret) const noexcept {
-        return ret ? (size_t)(ret - Ptr()) : npos;
-    }
+        return ret ? (size_t)(ret - Ptr()) : npos; 
+    } 
 
     inline size_t IterOff(const_iterator it) const noexcept {
         return begin() <= it && end() > it ? size_t(it - begin()) : npos;
     }
 
     inline const_iterator begin() const noexcept {
-        return Ptr();
-    }
+        return Ptr(); 
+    } 
 
     inline const_iterator end() const noexcept {
-        return Ptr() + size();
-    }
+        return Ptr() + size(); 
+    } 
 
     inline const_iterator cbegin() const noexcept {
         return begin();
@@ -169,8 +169,8 @@ public:
 
     inline TCharType back() const noexcept {
         Y_ASSERT(!this->empty());
-        return Ptr()[Len() - 1];
-    }
+        return Ptr()[Len() - 1]; 
+    } 
 
     inline TCharType front() const noexcept {
         Y_ASSERT(!empty());
@@ -182,20 +182,20 @@ public:
     }
 
     constexpr inline size_t size() const noexcept {
-        return Len();
-    }
+        return Len(); 
+    } 
 
     constexpr inline bool is_null() const noexcept {
-        return *Ptr() == 0;
-    }
+        return *Ptr() == 0; 
+    } 
 
     Y_PURE_FUNCTION constexpr inline bool empty() const noexcept {
-        return Len() == 0;
-    }
+        return Len() == 0; 
+    } 
 
     constexpr inline explicit operator bool() const noexcept {
         return !empty();
-    }
+    } 
 
 public: // style-guide compliant methods
     constexpr const TCharType* Data() const noexcept {
@@ -217,37 +217,37 @@ private:
     }
 
 public:
-    // ~~~ Comparison ~~~ : FAMILY0(int, compare)
+    // ~~~ Comparison ~~~ : FAMILY0(int, compare) 
     static int compare(const TSelf& s1, const TSelf& s2) noexcept {
         return s1.AsStringView().compare(s2.AsStringView());
-    }
+    } 
 
     static int compare(const TCharType* p, const TSelf& s2) noexcept {
         TCharType null{0};
         return TStringViewWithTraits(p ? p : &null).compare(s2.AsStringView());
-    }
+    } 
 
     static int compare(const TSelf& s1, const TCharType* p) noexcept {
         TCharType null{0};
         return s1.AsStringView().compare(p ? p : &null);
-    }
+    } 
 
     static int compare(const TStringView s1, const TStringView s2) noexcept {
         return TStringViewWithTraits(s1.data(), s1.size()).compare(TStringViewWithTraits(s2.data(), s2.size()));
-    }
+    } 
 
-    template <class T>
+    template <class T> 
     inline int compare(const T& t) const noexcept {
-        return compare(*this, t);
-    }
+        return compare(*this, t); 
+    } 
 
     inline int compare(size_t p, size_t n, const TStringView t) const noexcept {
         return compare(LegacySubString(*this, p, n), t);
-    }
+    } 
 
     inline int compare(size_t p, size_t n, const TStringView t, size_t p1, size_t n1) const noexcept {
         return compare(LegacySubString(*this, p, n), LegacySubString(t, p1, n1));
-    }
+    } 
 
     inline int compare(size_t p, size_t n, const TStringView t, size_t n1) const noexcept {
         return compare(LegacySubString(*this, p, n), LegacySubString(t, 0, n1));
@@ -277,10 +277,10 @@ public:
         return TStringViewWithTraits{s1.data(), s1.size()} == TStringViewWithTraits{s2.data(), s2.size()};
     }
 
-    template <class T>
+    template <class T> 
     inline bool equal(const T& t) const noexcept {
         return equal(*this, t);
-    }
+    } 
 
     inline bool equal(size_t p, size_t n, const TStringView t) const noexcept {
         return equal(LegacySubString(*this, p, n), t);
@@ -296,19 +296,19 @@ public:
 
     static inline bool StartsWith(const TCharType* what, size_t whatLen, const TCharType* with, size_t withLen) noexcept {
         return withLen <= whatLen && TStringViewWithTraits(what, withLen) == TStringViewWithTraits(with, withLen);
-    }
+    } 
 
     static inline bool EndsWith(const TCharType* what, size_t whatLen, const TCharType* with, size_t withLen) noexcept {
         return withLen <= whatLen && TStringViewWithTraits(what + whatLen - withLen, withLen) == TStringViewWithTraits(with, withLen);
-    }
+    } 
 
     inline bool StartsWith(const TCharType* s, size_t n) const noexcept {
         return StartsWith(Ptr(), Len(), s, n);
-    }
+    } 
 
     inline bool StartsWith(const TStringView s) const noexcept {
         return StartsWith(s.data(), s.length());
-    }
+    } 
 
     inline bool StartsWith(TCharType ch) const noexcept {
         return !empty() && TTraits::eq(*Ptr(), ch);
@@ -316,11 +316,11 @@ public:
 
     inline bool EndsWith(const TCharType* s, size_t n) const noexcept {
         return EndsWith(Ptr(), Len(), s, n);
-    }
+    } 
 
     inline bool EndsWith(const TStringView s) const noexcept {
         return EndsWith(s.data(), s.length());
-    }
+    } 
 
     inline bool EndsWith(TCharType ch) const noexcept {
         return !empty() && TTraits::eq(Ptr()[Len() - 1], ch);
@@ -329,7 +329,7 @@ public:
     template <typename TDerived2, typename TTraits2>
     bool operator==(const TStringBase<TDerived2, TChar, TTraits2>& s2) const noexcept {
         return equal(*this, s2);
-    }
+    } 
 
     bool operator==(TStringView s2) const noexcept {
         return equal(*this, s2);
@@ -337,17 +337,17 @@ public:
 
     bool operator==(const TCharType* pc) const noexcept {
         return equal(*this, pc);
-    }
+    } 
 
 #ifndef __cpp_impl_three_way_comparison
     friend bool operator==(const TCharType* pc, const TSelf& s) noexcept {
         return equal(pc, s);
-    }
+    } 
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator!=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
         return !(s1 == s2);
-    }
+    } 
 
     friend bool operator!=(const TSelf& s1, TStringView s2) noexcept {
         return !(s1 == s2);
@@ -355,114 +355,114 @@ public:
 
     friend bool operator!=(const TSelf& s, const TCharType* pc) noexcept {
         return !(s == pc);
-    }
+    } 
 
     friend bool operator!=(const TCharType* pc, const TSelf& s) noexcept {
         return !(pc == s);
-    }
+    } 
 #endif
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator<(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) < 0;
-    }
+        return compare(s1, s2) < 0; 
+    } 
 
     friend bool operator<(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) < 0;
     }
 
     friend bool operator<(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) < 0;
-    }
+        return compare(s, pc) < 0; 
+    } 
 
     friend bool operator<(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) < 0;
-    }
+        return compare(pc, s) < 0; 
+    } 
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator<=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) <= 0;
-    }
+        return compare(s1, s2) <= 0; 
+    } 
 
     friend bool operator<=(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) <= 0;
     }
 
     friend bool operator<=(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) <= 0;
-    }
+        return compare(s, pc) <= 0; 
+    } 
 
     friend bool operator<=(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) <= 0;
-    }
+        return compare(pc, s) <= 0; 
+    } 
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator>(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) > 0;
-    }
+        return compare(s1, s2) > 0; 
+    } 
 
     friend bool operator>(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) > 0;
     }
 
     friend bool operator>(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) > 0;
-    }
+        return compare(s, pc) > 0; 
+    } 
 
     friend bool operator>(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) > 0;
-    }
+        return compare(pc, s) > 0; 
+    } 
 
     template <typename TDerived2, typename TTraits2>
     friend bool operator>=(const TSelf& s1, const TStringBase<TDerived2, TChar, TTraits2>& s2) noexcept {
-        return compare(s1, s2) >= 0;
-    }
-
+        return compare(s1, s2) >= 0; 
+    } 
+ 
     friend bool operator>=(const TSelf& s1, TStringView s2) noexcept {
         return compare(s1, s2) >= 0;
     }
 
     friend bool operator>=(const TSelf& s, const TCharType* pc) noexcept {
-        return compare(s, pc) >= 0;
-    }
-
+        return compare(s, pc) >= 0; 
+    } 
+ 
     friend bool operator>=(const TCharType* pc, const TSelf& s) noexcept {
-        return compare(pc, s) >= 0;
-    }
-
-    // ~~ Read access ~~
+        return compare(pc, s) >= 0; 
+    } 
+ 
+    // ~~ Read access ~~ 
     inline TCharType at(size_t pos) const noexcept {
         if (Y_LIKELY(pos < Len())) {
-            return (Ptr())[pos];
+            return (Ptr())[pos]; 
         }
-        return 0;
-    }
+        return 0; 
+    } 
 
     inline TCharType operator[](size_t pos) const noexcept {
         Y_ASSERT(pos < this->size());
 
         return Ptr()[pos];
-    }
+    } 
 
-    //~~~~Search~~~~
+    //~~~~Search~~~~ 
     /**
      * @return                          Position of the substring inside this string, or `npos` if not found.
      */
     inline size_t find(const TStringView s, size_t pos = 0) const noexcept {
         return find(s.data(), pos, s.size());
-    }
-
+    } 
+ 
     inline size_t find(const TCharType* s, size_t pos, size_t count) const noexcept {
         return AsStringView().find(s, pos, count);
     }
 
     inline size_t find(TCharType c, size_t pos = 0) const noexcept {
         return AsStringView().find(c, pos);
-    }
+    } 
 
     inline size_t rfind(TCharType c) const noexcept {
         return AsStringView().rfind(c);
-    }
+    } 
 
     inline size_t rfind(TCharType c, size_t pos) const noexcept {
         if (pos == 0) {
@@ -491,11 +491,11 @@ public:
         return find(ui8(c), pos) != npos;
     }
 
-    //~~~~Character Set Search~~~
+    //~~~~Character Set Search~~~ 
     inline size_t find_first_of(TCharType c) const noexcept {
         return find_first_of(c, 0);
-    }
-
+    } 
+ 
     inline size_t find_first_of(TCharType c, size_t pos) const noexcept {
         return find(c, pos);
     }
@@ -506,8 +506,8 @@ public:
 
     inline size_t find_first_of(const TStringView set, size_t pos) const noexcept {
         return AsStringView().find_first_of(set.data(), pos, set.size());
-    }
-
+    } 
+ 
     inline size_t find_first_not_of(TCharType c) const noexcept {
         return find_first_not_of(c, 0);
     }
@@ -522,7 +522,7 @@ public:
 
     inline size_t find_first_not_of(const TStringView set, size_t pos) const noexcept {
         return AsStringView().find_first_not_of(set.data(), pos, set.size());
-    }
+    } 
 
     inline size_t find_last_of(TCharType c, size_t pos = npos) const noexcept {
         return find_last_of(&c, pos, 1);
@@ -534,7 +534,7 @@ public:
 
     inline size_t find_last_of(const TCharType* set, size_t pos, size_t n) const noexcept {
         return AsStringView().find_last_of(set, pos, n);
-    }
+    } 
 
     inline size_t find_last_not_of(TCharType c, size_t pos = npos) const noexcept {
         return AsStringView().find_last_not_of(c, pos);
@@ -548,37 +548,37 @@ public:
         return AsStringView().find_last_not_of(set, pos, n);
     }
 
-    inline size_t copy(TCharType* pc, size_t n, size_t pos) const {
+    inline size_t copy(TCharType* pc, size_t n, size_t pos) const { 
         if (pos > Len()) {
             throw std::out_of_range("TStringBase::copy");
         }
 
-        return CopyImpl(pc, n, pos);
-    }
+        return CopyImpl(pc, n, pos); 
+    } 
 
     inline size_t copy(TCharType* pc, size_t n) const noexcept {
         return CopyImpl(pc, n, 0);
-    }
+    } 
 
     inline size_t strcpy(TCharType* pc, size_t n) const noexcept {
-        if (n) {
+        if (n) { 
             n = copy(pc, n - 1);
             pc[n] = 0;
         }
 
         return n;
-    }
+    } 
 
     inline TDerived copy() const Y_WARN_UNUSED_RESULT {
-        return TDerived(Ptr(), Len());
-    }
+        return TDerived(Ptr(), Len()); 
+    } 
 
     // ~~~ Partial copy ~~~~
     TDerived substr(size_t pos, size_t n = npos) const Y_WARN_UNUSED_RESULT {
         return TDerived(*This(), pos, n);
     }
 
-private:
+private: 
     using GenericFinder = const TCharType* (*)(const TCharType*, size_t, const TCharType*, size_t);
 
     TStringViewWithTraits AsStringView() const {
@@ -586,22 +586,22 @@ private:
     }
 
     constexpr inline const TCharType* Ptr() const noexcept {
-        return This()->data();
-    }
+        return This()->data(); 
+    } 
 
     constexpr inline size_t Len() const noexcept {
-        return This()->length();
-    }
-
+        return This()->length(); 
+    } 
+ 
     constexpr inline const TDerived* This() const noexcept {
-        return static_cast<const TDerived*>(this);
-    }
-
+        return static_cast<const TDerived*>(this); 
+    } 
+ 
     inline size_t CopyImpl(TCharType* pc, size_t n, size_t pos) const noexcept {
-        const size_t toCopy = Min(Len() - pos, n);
+        const size_t toCopy = Min(Len() - pos, n); 
 
         TTraits::copy(pc, Ptr() + pos, toCopy);
 
-        return toCopy;
-    }
+        return toCopy; 
+    } 
 };
diff --git a/util/generic/string.cpp b/util/generic/string.cpp
index 3c655f1f66..07e7053cfc 100644
--- a/util/generic/string.cpp
+++ b/util/generic/string.cpp
@@ -4,12 +4,12 @@
 #include <util/system/sanitizers.h>
 #include <util/system/sys_alloc.h>
 #include <util/charset/wide.h>
-
+ 
 #include <iostream>
 #include <cctype>
 
 alignas(32) const char NULL_STRING_REPR[128] = {0};
-
+ 
 std::ostream& operator<<(std::ostream& os, const TString& s) {
     return os.write(s.data(), s.size());
 }
diff --git a/util/generic/string.h b/util/generic/string.h
index 8cd8aa6917..04c9c08132 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -8,7 +8,7 @@
 #include <string_view>
 
 #include <util/system/yassert.h>
-#include <util/system/atomic.h>
+#include <util/system/atomic.h> 
 
 #include "ptr.h"
 #include "utility.h"
@@ -61,11 +61,11 @@ public:
 };
 
 alignas(32) extern const char NULL_STRING_REPR[128];
-
+ 
 struct TRefCountHolder {
     TAtomicCounter C = 1;
 };
-
+ 
 template <class B>
 struct TStdString: public TRefCountHolder, public B {
     template <typename... Args>
@@ -73,7 +73,7 @@ struct TStdString: public TRefCountHolder, public B {
         : B(std::forward<Args>(args)...)
     {
     }
-
+ 
     inline bool IsNull() const noexcept {
         return this == NullStr();
     }
@@ -97,12 +97,12 @@ private:
             delete this;
         }
     }
-
+ 
     inline long RefCount() const noexcept {
         return C.Val();
     }
 };
-
+ 
 template <class TStringType>
 class TBasicCharRef {
 public:
@@ -157,7 +157,7 @@ private:
 
 template <typename TCharType, typename TTraits>
 class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
-public:
+public: 
     // TODO: Move to private section
     using TBase = TStringBase<TBasicString, TCharType, TTraits>;
     using TStringType = std::basic_string<TCharType, TTraits>;
@@ -172,13 +172,13 @@ public:
     using char_type = TCharType; // TODO: DROP
     using value_type = TCharType;
     using traits_type = TTraits;
-
+ 
     using iterator = TCharType*;
     using reverse_iterator = typename TBase::template TReverseIteratorBase<iterator>;
     using typename TBase::const_iterator;
     using typename TBase::const_reference;
     using typename TBase::const_reverse_iterator;
-
+ 
     struct TUninitialized {
         explicit TUninitialized(size_t size)
             : Size(size)
@@ -194,12 +194,12 @@ public:
         return res;
     }
 
-protected:
+protected: 
 #ifdef TSTRING_IS_STD_STRING
     TStorage Storage_;
 #else
     TStorage S_;
-
+ 
     template <typename... A>
     static TStorage Construct(A&&... a) {
         return {new TStdStr(std::forward<A>(a)...), typename TStorage::TNoIncrement()};
@@ -222,7 +222,7 @@ protected:
      *
      * @throw std::length_error
      */
-    void Clone() {
+    void Clone() { 
         Construct(StdStr()).Swap(S_);
     }
 
@@ -331,7 +331,7 @@ public:
     using TBase::end;     //!< const_iterator TStringBase::end() const
     using TBase::rbegin;  //!< const_reverse_iterator TStringBase::rbegin() const
     using TBase::rend;    //!< const_reverse_iterator TStringBase::rend() const
-
+ 
     inline size_t capacity() const noexcept {
 #ifdef TSTRING_IS_STD_STRING
         return Storage_.capacity();
@@ -369,7 +369,7 @@ public:
         MutRef().resize(n, c);
 
         return *this;
-    }
+    } 
 
     // ~~~ Constructor ~~~ : FAMILY0(,TBasicString)
     TBasicString() noexcept
@@ -409,7 +409,7 @@ public:
 #endif
     }
 
-    template <typename T, typename A>
+    template <typename T, typename A> 
     explicit inline TBasicString(const std::basic_string<TCharType, T, A>& s)
         : TBasicString(s.data(), s.size())
     {
@@ -432,12 +432,12 @@ public:
         : S_(n ? Construct(s, pos, n) : Construct())
 #endif
     {
-    }
+    } 
 
     TBasicString(const TCharType* pc)
         : TBasicString(pc, TBase::StrLen(pc))
     {
-    }
+    } 
     // TODO thegeorg@: uncomment and fix clients
     // TBasicString(std::nullptr_t) = delete;
 
@@ -448,14 +448,14 @@ public:
         : S_(n ? Construct(pc, n) : Construct())
 #endif
     {
-    }
+    } 
     TBasicString(std::nullptr_t, size_t) = delete;
-
+ 
     TBasicString(const TCharType* pc, size_t pos, size_t n)
         : TBasicString(pc + pos, n)
     {
-    }
-
+    } 
+ 
 #ifdef TSTRING_IS_STD_STRING
     explicit TBasicString(TExplicitType<TCharType> c) {
         Storage_.push_back(c);
@@ -464,7 +464,7 @@ public:
     explicit TBasicString(TExplicitType<TCharType> c)
         : TBasicString(&c.Value(), 1)
     {
-    }
+    } 
     explicit TBasicString(const reference& c)
         : TBasicString(&c, 1)
     {
@@ -478,8 +478,8 @@ public:
         : S_(Construct(n, c))
 #endif
     {
-    }
-
+    } 
+ 
     /**
      * Constructs an uninitialized string of size `uninitialized.Size`. The proper
      * way to use this ctor is via `TBasicString::Uninitialized` factory function.
@@ -491,13 +491,13 @@ public:
         S_ = Construct();
 #endif
         ReserveAndResize(uninitialized.Size);
-    }
-
+    } 
+ 
     TBasicString(const TCharType* b, const TCharType* e)
         : TBasicString(b, e - b)
     {
-    }
-
+    } 
+ 
     explicit TBasicString(const TBasicStringBuf<TCharType, TTraits> s)
         : TBasicString(s.data(), s.size())
     {
@@ -534,7 +534,7 @@ private:
     template <typename... R>
     static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
         return s1.size() + SumLength(r...);
-    }
+    } 
 
     template <typename... R>
     static size_t SumLength(const TCharType /*s1*/, const R&... r) noexcept {
@@ -543,8 +543,8 @@ private:
 
     static constexpr size_t SumLength() noexcept {
         return 0;
-    }
-
+    } 
+ 
     template <typename... R>
     static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
         TTraits::copy(p, s.data(), s.size());
@@ -800,7 +800,7 @@ public:
 
     TBasicString& AppendUtf16(const ::TWtringBuf& s);
 
-    inline void push_back(TCharType c) {
+    inline void push_back(TCharType c) { 
         // TODO
         append(c);
     }
@@ -1047,11 +1047,11 @@ public:
     TBasicString& remove(size_t pos = 0) Y_NOEXCEPT {
         if (pos < length()) {
             MutRef().erase(pos);
-        }
+        } 
 
         return *this;
-    }
-
+    } 
+ 
     TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT {
         MutRef().erase(pos, n);
 
@@ -1109,8 +1109,8 @@ public:
         MutRef().replace(pos, n1, n2, c);
 
         return *this;
-    }
-
+    } 
+ 
     TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT {
         MutRef().replace(pos, n, s, spos, sn);
 
@@ -1123,8 +1123,8 @@ public:
 #else
         S_.Swap(s.S_);
 #endif
-    }
-
+    } 
+ 
     /**
      * @returns                         String suitable for debug printing (like Python's `repr()`).
      *                                  Format of the string is unspecified and may be changed over time.
@@ -1189,8 +1189,8 @@ public:
 
         return changed;
     }
-};
-
+}; 
+ 
 std::ostream& operator<<(std::ostream&, const TString&);
 std::istream& operator>>(std::istream&, TString&);
 
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index ac82e9091d..8fc87cc0a1 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -21,13 +21,13 @@ static_assert(sizeof(TString) == sizeof(const char*), "expect sizeof(TString) ==
 #endif
 
 class TStringTestZero: public TTestBase {
-    UNIT_TEST_SUITE(TStringTestZero);
+    UNIT_TEST_SUITE(TStringTestZero); 
     UNIT_TEST(TestZero);
     UNIT_TEST_SUITE_END();
 
 public:
     void TestZero() {
-        const char data[] = "abc\0def\0";
+        const char data[] = "abc\0def\0"; 
         TString s(data, sizeof(data));
         UNIT_ASSERT(s.size() == sizeof(data));
         UNIT_ASSERT(s.StartsWith(s));
@@ -49,60 +49,60 @@ public:
 
         TString copy = s;
         copy.replace(copy.size() - 1, 1, "z");
-        UNIT_ASSERT(s != copy);
+        UNIT_ASSERT(s != copy); 
         copy.replace(copy.size() - 1, 1, "\0", 0, 1);
-        UNIT_ASSERT(s == copy);
+        UNIT_ASSERT(s == copy); 
 
         TString prefix(data, 5);
         UNIT_ASSERT(s.StartsWith(prefix));
-        UNIT_ASSERT(s != prefix);
-        UNIT_ASSERT(s > prefix);
+        UNIT_ASSERT(s != prefix); 
+        UNIT_ASSERT(s > prefix); 
         UNIT_ASSERT(s > s.data());
         UNIT_ASSERT(s == TString(s.data(), s.size()));
-        UNIT_ASSERT(data < s);
-
-        s.remove(5);
-        UNIT_ASSERT(s == prefix);
-    }
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TStringTestZero);
-
+        UNIT_ASSERT(data < s); 
+
+        s.remove(5); 
+        UNIT_ASSERT(s == prefix); 
+    } 
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TStringTestZero); 
+ 
 template <typename TStringType, typename TTestData>
-class TStringStdTestImpl {
+class TStringStdTestImpl { 
     using TChar = typename TStringType::char_type;
     using TTraits = typename TStringType::traits_type;
     using TView = std::basic_string_view<TChar, TTraits>;
-
+ 
     TTestData Data_;
-
-protected:
+ 
+protected: 
     void Constructor() {
-        // @todo use UNIT_TEST_EXCEPTION
-        try {
+        // @todo use UNIT_TEST_EXCEPTION 
+        try { 
             TStringType s((size_t)-1, *Data_.a());
-            UNIT_ASSERT(false);
-        } catch (const std::length_error&) {
-            UNIT_ASSERT(true);
-        } catch (...) {
-            //Expected exception is length_error:
-            UNIT_ASSERT(false);
-        }
+            UNIT_ASSERT(false); 
+        } catch (const std::length_error&) { 
+            UNIT_ASSERT(true); 
+        } catch (...) { 
+            //Expected exception is length_error: 
+            UNIT_ASSERT(false); 
+        } 
     }
 
-    void reserve() {
+    void reserve() { 
 #if 0
         TStringType s;
-        // @todo use UNIT_TEST_EXCEPTION
-        try {
-            s.reserve(s.max_size() + 1);
-            UNIT_ASSERT(false);
-        } catch (const std::length_error&) {
-            UNIT_ASSERT(true);
-        } catch (...) {
-            //Expected exception is length_error:
-            UNIT_ASSERT(false);
-        }
+        // @todo use UNIT_TEST_EXCEPTION 
+        try { 
+            s.reserve(s.max_size() + 1); 
+            UNIT_ASSERT(false); 
+        } catch (const std::length_error&) { 
+            UNIT_ASSERT(true); 
+        } catch (...) { 
+            //Expected exception is length_error: 
+            UNIT_ASSERT(false); 
+        } 
 
         // Non-shared behaviour - never shrink
 
@@ -150,149 +150,149 @@ protected:
 #endif
     }
 
-    void short_string() {
+    void short_string() { 
         TStringType const ref_short_str1(Data_.str1()), ref_short_str2(Data_.str2());
         TStringType short_str1(ref_short_str1), short_str2(ref_short_str2);
         TStringType const ref_long_str1(Data_.str__________________________________________________1());
         TStringType const ref_long_str2(Data_.str__________________________________________________2());
         TStringType long_str1(ref_long_str1), long_str2(ref_long_str2);
 
-        UNIT_ASSERT(short_str1 == ref_short_str1);
-        UNIT_ASSERT(long_str1 == ref_long_str1);
+        UNIT_ASSERT(short_str1 == ref_short_str1); 
+        UNIT_ASSERT(long_str1 == ref_long_str1); 
 
-        {
+        { 
             TStringType str1(short_str1);
-            str1 = long_str1;
-            UNIT_ASSERT(str1 == ref_long_str1);
-        }
+            str1 = long_str1; 
+            UNIT_ASSERT(str1 == ref_long_str1); 
+        } 
 
-        {
+        { 
             TStringType str1(long_str1);
-            str1 = short_str1;
-            UNIT_ASSERT(str1 == ref_short_str1);
-        }
-
-        {
-            short_str1.swap(short_str2);
-            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
-            short_str1.swap(short_str2);
-        }
-
-        {
-            long_str1.swap(long_str2);
-            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
-            long_str1.swap(long_str2);
-        }
-
-        {
-            short_str1.swap(long_str1);
-            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
-            short_str1.swap(long_str1);
-        }
-
-        {
-            long_str1.swap(short_str1);
-            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
-            long_str1.swap(short_str1);
-        }
-
-        {
-            //This is to test move constructor
+            str1 = short_str1; 
+            UNIT_ASSERT(str1 == ref_short_str1); 
+        } 
+
+        { 
+            short_str1.swap(short_str2); 
+            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1)); 
+            short_str1.swap(short_str2); 
+        } 
+
+        { 
+            long_str1.swap(long_str2); 
+            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1)); 
+            long_str1.swap(long_str2); 
+        } 
+
+        { 
+            short_str1.swap(long_str1); 
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1)); 
+            short_str1.swap(long_str1); 
+        } 
+
+        { 
+            long_str1.swap(short_str1); 
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1)); 
+            long_str1.swap(short_str1); 
+        } 
+
+        { 
+            //This is to test move constructor 
             TVector<TStringType> str_vect;
 
-            str_vect.push_back(short_str1);
-            str_vect.push_back(long_str1);
-            str_vect.push_back(short_str2);
-            str_vect.push_back(long_str2);
+            str_vect.push_back(short_str1); 
+            str_vect.push_back(long_str1); 
+            str_vect.push_back(short_str2); 
+            str_vect.push_back(long_str2); 
 
             UNIT_ASSERT(str_vect[0] == ref_short_str1);
             UNIT_ASSERT(str_vect[1] == ref_long_str1);
             UNIT_ASSERT(str_vect[2] == ref_short_str2);
             UNIT_ASSERT(str_vect[3] == ref_long_str2);
-        }
+        } 
     }
 
-    void erase() {
+    void erase() { 
         TChar const* c_str = Data_.Hello_World();
         TStringType str(c_str);
-        UNIT_ASSERT(str == c_str);
+        UNIT_ASSERT(str == c_str); 
 
-        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.
+        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last. 
 
-        size_t i;
-        for (i = 0; i < str.size(); ++i) {
-            switch (i) {
-                case 0:
+        size_t i; 
+        for (i = 0; i < str.size(); ++i) { 
+            switch (i) { 
+                case 0: 
                     UNIT_ASSERT(str[i] == *Data_.H());
-                    break;
+                    break; 
 
-                case 1:
+                case 1: 
                     UNIT_ASSERT(str[i] == *Data_.d());
-                    break;
+                    break; 
 
-                default:
-                    UNIT_ASSERT(false);
-            }
+                default: 
+                    UNIT_ASSERT(false); 
+            } 
         }
 
-        str.insert(1, c_str);
+        str.insert(1, c_str); 
         str.erase(str.begin());   // Erase first element.
-        str.erase(str.end() - 1); // Erase last element.
-        UNIT_ASSERT(str == c_str);
-        str.clear(); // Erase all.
-        UNIT_ASSERT(str.empty());
-
-        str = c_str;
-        UNIT_ASSERT(str == c_str);
-
-        str.erase(1, str.size() - 1); // Erase all but first and last.
-        for (i = 0; i < str.size(); i++) {
-            switch (i) {
-                case 0:
+        str.erase(str.end() - 1); // Erase last element. 
+        UNIT_ASSERT(str == c_str); 
+        str.clear(); // Erase all. 
+        UNIT_ASSERT(str.empty()); 
+
+        str = c_str; 
+        UNIT_ASSERT(str == c_str); 
+
+        str.erase(1, str.size() - 1); // Erase all but first and last. 
+        for (i = 0; i < str.size(); i++) { 
+            switch (i) { 
+                case 0: 
                     UNIT_ASSERT(str[i] == *Data_.H());
-                    break;
+                    break; 
 
-                case 1:
+                case 1: 
                     UNIT_ASSERT(str[i] == *Data_.d());
-                    break;
+                    break; 
 
-                default:
-                    UNIT_ASSERT(false);
-            }
+                default: 
+                    UNIT_ASSERT(false); 
+            } 
         }
-
-        str.erase(1);
+ 
+        str.erase(1); 
         UNIT_ASSERT(str == Data_.H());
     }
 
-    void data() {
+    void data() { 
         TStringType xx;
 
-        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3 
         UNIT_ASSERT(xx.data() != nullptr);
-    }
+    } 
 
-    void c_str() {
+    void c_str() { 
         TStringType low(Data_._2004_01_01());
         TStringType xx;
         TStringType yy;
 
-        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
-        UNIT_ASSERT(*(yy.c_str()) == 0);
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1 
+        UNIT_ASSERT(*(yy.c_str()) == 0); 
 
-        // Blocks A and B should follow each other.
-        // Block A:
+        // Blocks A and B should follow each other. 
+        // Block A: 
         xx = Data_._123456();
-        xx += low;
+        xx += low; 
         UNIT_ASSERT(xx.c_str() == TView(Data_._1234562004_01_01()));
-        // End of block A
+        // End of block A 
 
-        // Block B:
+        // Block B: 
         xx = Data_._1234();
         xx += Data_._5();
         UNIT_ASSERT(xx.c_str() == TView(Data_._12345()));
-        // End of block B
-    }
+        // End of block B 
+    } 
 
     void null_char_of_empty() {
         const TStringType s;
@@ -300,8 +300,8 @@ protected:
         UNIT_ASSERT(s[s.size()] == 0);
     }
 
-    void null_char() {
-        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
+    void null_char() { 
+        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version') 
         const TStringType s(Data_._123456());
 
         UNIT_ASSERT(s[s.size()] == 0);
@@ -315,11 +315,11 @@ protected:
         using reference = volatile typename TStringType::value_type&;
 #else
         using reference = typename TStringType::reference;
-#endif
+#endif 
         reference trailing_zero = s[s.size()];
         trailing_zero = 0;
         UNIT_ASSERT(trailing_zero == 0);
-    }
+    } 
 
     // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
     void null_char_assignment_to_subscript_of_nonempty() {
@@ -355,45 +355,45 @@ protected:
     }
 #endif
 
-    void insert() {
+    void insert() { 
         TStringType strorg = Data_.This_is_test_string_for_string_calls();
         TStringType str;
 
-        // In case of reallocation there is no auto reference problem
+        // In case of reallocation there is no auto reference problem 
         // so we reserve a big enough TStringType to be sure to test this
-        // particular point.
+        // particular point. 
 
-        str.reserve(100);
-        str = strorg;
+        str.reserve(100); 
+        str = strorg; 
 
-        //test self insertion:
-        str.insert(10, str.c_str() + 5, 15);
+        //test self insertion: 
+        str.insert(10, str.c_str() + 5, 15); 
         UNIT_ASSERT(str == Data_.This_is_teis_test_string_st_string_for_string_calls());
 
-        str = strorg;
-        str.insert(15, str.c_str() + 5, 25);
+        str = strorg; 
+        str.insert(15, str.c_str() + 5, 25); 
         UNIT_ASSERT(str == Data_.This_is_test_stis_test_string_for_stringring_for_string_calls());
 
-        str = strorg;
-        str.insert(0, str.c_str() + str.size() - 4, 4);
+        str = strorg; 
+        str.insert(0, str.c_str() + str.size() - 4, 4); 
         UNIT_ASSERT(str == Data_.allsThis_is_test_string_for_string_calls());
 
-        str = strorg;
-        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
+        str = strorg; 
+        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1); 
         UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
 
-        str = strorg;
+        str = strorg; 
         typename TStringType::iterator b = str.begin();
         typename TStringType::const_iterator s = str.begin() + str.size() / 2 - 1;
         typename TStringType::const_iterator e = str.end();
-        str.insert(b, s, e);
+        str.insert(b, s, e); 
         UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
 
 #if 0
-        // AV
-        str = strorg;
-        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
-        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls());
+        // AV 
+        str = strorg; 
+        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end()); 
+        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls()); 
 #endif
 
         TStringType str0;
@@ -401,17 +401,17 @@ protected:
         UNIT_ASSERT(str0 == Data_._00000());
 
         TStringType str1;
-        {
+        { 
             typename TStringType::size_type pos = 0, nb = 2;
             str1.insert(pos, nb, *Data_._1());
-        }
+        } 
         UNIT_ASSERT(str1 == Data_._11());
 
-        str0.insert(0, str1);
+        str0.insert(0, str1); 
         UNIT_ASSERT(str0 == Data_._1100000());
 
         TStringType str2(Data_._2345());
-        str0.insert(str0.size(), str2, 1, 2);
+        str0.insert(str0.size(), str2, 1, 2); 
         UNIT_ASSERT(str0 == Data_._110000034());
 
         str1.insert(str1.begin() + 1, 2, *Data_._2());
@@ -425,40 +425,40 @@ protected:
 
         str1.insert(str1.begin() + 6, *Data_._5());
         UNIT_ASSERT(str1 == Data_._123344544321());
-    }
+    } 
 
-    void resize() {
+    void resize() { 
         TStringType s;
 
-        s.resize(0);
+        s.resize(0); 
 
-        UNIT_ASSERT(*s.c_str() == 0);
+        UNIT_ASSERT(*s.c_str() == 0); 
 
         s = Data_._1234567();
 
-        s.resize(0);
-        UNIT_ASSERT(*s.c_str() == 0);
+        s.resize(0); 
+        UNIT_ASSERT(*s.c_str() == 0); 
 
         s = Data_._1234567();
-        s.resize(1);
-        UNIT_ASSERT(s.size() == 1);
+        s.resize(1); 
+        UNIT_ASSERT(s.size() == 1); 
         UNIT_ASSERT(*s.c_str() == *Data_._1());
-        UNIT_ASSERT(*(s.c_str() + 1) == 0);
+        UNIT_ASSERT(*(s.c_str() + 1) == 0); 
 
         s = Data_._1234567();
 #if 0
-        s.resize(10);
+        s.resize(10); 
 #else
-        s.resize(10, 0);
+        s.resize(10, 0); 
 #endif
-        UNIT_ASSERT(s.size() == 10);
+        UNIT_ASSERT(s.size() == 10); 
         UNIT_ASSERT(s[6] == *Data_._7());
-        UNIT_ASSERT(s[7] == 0);
-        UNIT_ASSERT(s[8] == 0);
-        UNIT_ASSERT(s[9] == 0);
-    }
+        UNIT_ASSERT(s[7] == 0); 
+        UNIT_ASSERT(s[8] == 0); 
+        UNIT_ASSERT(s[9] == 0); 
+    } 
 
-    void find() {
+    void find() { 
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find(Data_.one()) == 0);
@@ -469,33 +469,33 @@ protected:
         UNIT_ASSERT(s.find(Data_.one(), TStringType::npos) == TStringType::npos);
         UNIT_ASSERT(s.find_first_of(Data_.abcde()) == 2);
         UNIT_ASSERT(s.find_first_not_of(Data_.enotw_()) == 9);
-    }
+    } 
 
-    void capacity() {
+    void capacity() { 
         TStringType s;
 
         UNIT_ASSERT(s.capacity() < s.max_size());
         UNIT_ASSERT(s.capacity() >= s.size());
-
-        for (int i = 0; i < 18; ++i) {
-            s += ' ';
-
+ 
+        for (int i = 0; i < 18; ++i) { 
+            s += ' '; 
+ 
             UNIT_ASSERT(s.capacity() > 0);
             UNIT_ASSERT(s.capacity() < s.max_size());
             UNIT_ASSERT(s.capacity() >= s.size());
-        }
+        } 
     }
 
-    void assign() {
+    void assign() { 
         TStringType s;
         TChar const* cstr = Data_.test_string_for_assign();
 
-        s.assign(cstr, cstr + 22);
+        s.assign(cstr, cstr + 22); 
         UNIT_ASSERT(s == Data_.test_string_for_assign());
 
         TStringType s2(Data_.other_test_string());
-        s.assign(s2);
-        UNIT_ASSERT(s == s2);
+        s.assign(s2); 
+        UNIT_ASSERT(s == s2); 
 
         static TStringType str1;
         static TStringType str2;
@@ -507,34 +507,34 @@ protected:
 
         UNIT_ASSERT(str1[5] == *Data_._6());
         UNIT_ASSERT(str2[29] == *Data_._0());
-    }
+    } 
 
-    void copy() {
+    void copy() { 
         TStringType s(Data_.foo());
         TChar dest[4];
-        dest[0] = dest[1] = dest[2] = dest[3] = 1;
-        s.copy(dest, 4);
-        int pos = 0;
+        dest[0] = dest[1] = dest[2] = dest[3] = 1; 
+        s.copy(dest, 4); 
+        int pos = 0; 
         UNIT_ASSERT(dest[pos++] == *Data_.f());
         UNIT_ASSERT(dest[pos++] == *Data_.o());
         UNIT_ASSERT(dest[pos++] == *Data_.o());
-        UNIT_ASSERT(dest[pos++] == 1);
+        UNIT_ASSERT(dest[pos++] == 1); 
 
-        dest[0] = dest[1] = dest[2] = dest[3] = 1;
-        s.copy(dest, 4, 2);
-        pos = 0;
+        dest[0] = dest[1] = dest[2] = dest[3] = 1; 
+        s.copy(dest, 4, 2); 
+        pos = 0; 
         UNIT_ASSERT(dest[pos++] == *Data_.o());
-        UNIT_ASSERT(dest[pos++] == 1);
-
-        // @todo use UNIT_TEST_EXCEPTION
-        try {
-            s.copy(dest, 4, 5);
-            UNIT_ASSERT(!"expected std::out_of_range");
-        } catch (const std::out_of_range&) {
-            UNIT_ASSERT(true);
+        UNIT_ASSERT(dest[pos++] == 1); 
+
+        // @todo use UNIT_TEST_EXCEPTION 
+        try { 
+            s.copy(dest, 4, 5); 
+            UNIT_ASSERT(!"expected std::out_of_range"); 
+        } catch (const std::out_of_range&) { 
+            UNIT_ASSERT(true); 
         } catch (...) {
-            UNIT_ASSERT(!"expected std::out_of_range");
-        }
+            UNIT_ASSERT(!"expected std::out_of_range"); 
+        } 
     }
 
     void cbegin_cend() {
@@ -546,18 +546,18 @@ protected:
         }
     }
 
-    void compare() {
+    void compare() { 
         TStringType str1(Data_.abcdef());
         TStringType str2;
 
         str2 = Data_.abcdef();
-        UNIT_ASSERT(str1.compare(str2) == 0);
+        UNIT_ASSERT(str1.compare(str2) == 0); 
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) == 0);
         str2 = Data_.abcde();
-        UNIT_ASSERT(str1.compare(str2) > 0);
+        UNIT_ASSERT(str1.compare(str2) > 0); 
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) > 0);
         str2 = Data_.abcdefg();
-        UNIT_ASSERT(str1.compare(str2) < 0);
+        UNIT_ASSERT(str1.compare(str2) < 0); 
         UNIT_ASSERT(str1.compare(str2.data(), str2.size()) < 0);
 
         UNIT_ASSERT(str1.compare(Data_.abcdef()) == 0);
@@ -565,24 +565,24 @@ protected:
         UNIT_ASSERT(str1.compare(Data_.abcdefg()) < 0);
 
         str2 = Data_.cde();
-        UNIT_ASSERT(str1.compare(2, 3, str2) == 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2) == 0); 
         str2 = Data_.cd();
-        UNIT_ASSERT(str1.compare(2, 3, str2) > 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2) > 0); 
         str2 = Data_.cdef();
-        UNIT_ASSERT(str1.compare(2, 3, str2) < 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2) < 0); 
 
         str2 = Data_.abcdef();
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0);
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0);
-        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0); 
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0); 
 
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 3) == 0);
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 2) > 0);
         UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 4) < 0);
-    }
+    } 
 
-    void find_last_of() {
-        // 21.3.6.4
+    void find_last_of() { 
+        // 21.3.6.4 
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find_last_of(Data_.abcde()) == 26);
@@ -597,16 +597,16 @@ protected:
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 2) == 2);
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 1) == 0);
         UNIT_ASSERT(test.find_last_of(*Data_.a(), 0) == 0);
-    }
+    } 
 #if 0
-    void rfind() {
-        // 21.3.6.2
+    void rfind() { 
+        // 21.3.6.2 
         TStringType s(Data.one_two_three_one_two_three());
 
-        UNIT_ASSERT(s.rfind(Data.two()) == 18);
+        UNIT_ASSERT(s.rfind(Data.two()) == 18); 
         UNIT_ASSERT(s.rfind(Data.two(), 0) == TStringType::npos);
-        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4);
-        UNIT_ASSERT(s.rfind(*Data.w()) == 19);
+        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4); 
+        UNIT_ASSERT(s.rfind(*Data.w()) == 19); 
 
         TStringType test(Data.aba());
 
@@ -617,10 +617,10 @@ protected:
         UNIT_ASSERT(test.rfind(*Data.a(), 2) == 2);
         UNIT_ASSERT(test.rfind(*Data.a(), 1) == 0);
         UNIT_ASSERT(test.rfind(*Data.a(), 0) == 0);
-    }
+    } 
 #endif
-    void find_last_not_of() {
-        // 21.3.6.6
+    void find_last_not_of() { 
+        // 21.3.6.6 
         TStringType s(Data_.one_two_three_one_two_three());
 
         UNIT_ASSERT(s.find_last_not_of(Data_.ehortw_()) == 15);
@@ -640,90 +640,90 @@ protected:
         UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 1) == 0);
         UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 0) == TStringType::npos);
         UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 0) == 0);
-    }
+    } 
 #if 0
-    void replace() {
+    void replace() { 
         // This test case is for the non template basic_TString::replace method,
-        // this is why we play with the const iterators and reference to guaranty
-        // that the right method is called.
+        // this is why we play with the const iterators and reference to guaranty 
+        // that the right method is called. 
 
         const TStringType v(Data._78());
         TStringType s(Data._123456());
         TStringType const& cs = s;
 
         typename TStringType::iterator i = s.begin() + 1;
-        s.replace(i, i + 3, v.begin(), v.end());
+        s.replace(i, i + 3, v.begin(), v.end()); 
         UNIT_ASSERT(s == Data._17856());
 
-        s = Data._123456();
-        i = s.begin() + 1;
-        s.replace(i, i + 1, v.begin(), v.end());
+        s = Data._123456(); 
+        i = s.begin() + 1; 
+        s.replace(i, i + 1, v.begin(), v.end()); 
         UNIT_ASSERT(s == Data._1783456());
 
-        s = Data._123456();
-        i = s.begin() + 1;
+        s = Data._123456(); 
+        i = s.begin() + 1; 
         typename TStringType::const_iterator ci = s.begin() + 1;
-        s.replace(i, i + 3, ci + 3, cs.end());
+        s.replace(i, i + 3, ci + 3, cs.end()); 
         UNIT_ASSERT(s == Data._15656());
 
-        s = Data._123456();
-        i = s.begin() + 1;
-        ci = s.begin() + 1;
-        s.replace(i, i + 3, ci, ci + 2);
+        s = Data._123456(); 
+        i = s.begin() + 1; 
+        ci = s.begin() + 1; 
+        s.replace(i, i + 3, ci, ci + 2); 
         UNIT_ASSERT(s == Data._12356());
 
-        s = Data._123456();
-        i = s.begin() + 1;
-        ci = s.begin() + 1;
-        s.replace(i, i + 3, ci + 1, cs.end());
+        s = Data._123456(); 
+        i = s.begin() + 1; 
+        ci = s.begin() + 1; 
+        s.replace(i, i + 3, ci + 1, cs.end()); 
         UNIT_ASSERT(s == Data._1345656());
 
-        s = Data._123456();
-        i = s.begin();
-        ci = s.begin() + 1;
-        s.replace(i, i, ci, ci + 1);
+        s = Data._123456(); 
+        i = s.begin(); 
+        ci = s.begin() + 1; 
+        s.replace(i, i, ci, ci + 1); 
         UNIT_ASSERT(s == Data._2123456());
 
-        s = Data._123456();
-        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
+        s = Data._123456(); 
+        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end()); 
         UNIT_ASSERT(s == Data._1234123456());
 
-        // This is the test for the template replace method.
+        // This is the test for the template replace method. 
 
-        s = Data._123456();
+        s = Data._123456(); 
         typename TStringType::iterator b = s.begin() + 4;
         typename TStringType::iterator e = s.end();
         typename TStringType::const_iterator rb = s.begin();
         typename TStringType::const_iterator re = s.end();
-        s.replace(b, e, rb, re);
+        s.replace(b, e, rb, re); 
         UNIT_ASSERT(s == Data._1234123456());
 
-        s = Data._123456();
-        s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
+        s = Data._123456(); 
+        s.replace(s.begin() + 4, s.end(), s.begin(), s.end()); 
         UNIT_ASSERT(s == Data._1234123456());
 
         TStringType strorg(Data.This_is_test_StringT_for_StringT_calls());
         TStringType str = strorg;
-        str.replace(5, 15, str.c_str(), 10);
+        str.replace(5, 15, str.c_str(), 10); 
         UNIT_ASSERT(str == Data.This_This_is_tefor_StringT_calls());
 
-        str = strorg;
-        str.replace(5, 5, str.c_str(), 10);
+        str = strorg; 
+        str.replace(5, 5, str.c_str(), 10); 
         UNIT_ASSERT(str == Data.This_This_is_test_StringT_for_StringT_calls());
 
     #if !defined(STLPORT) || defined(_STLP_MEMBER_TEMPLATES)
         deque<TChar> cdeque;
-        cdeque.push_back(*Data.I());
-        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
+        cdeque.push_back(*Data.I()); 
+        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end()); 
         UNIT_ASSERT(str == Data.Is_test_StringT_for_StringT_calls());
     #endif
-    }
+    } 
 #endif
-}; // TStringStdTestImpl
-
+}; // TStringStdTestImpl 
+ 
 class TStringTest: public TTestBase, private TStringTestImpl<TString, TTestData<char>> {
-public:
-    UNIT_TEST_SUITE(TStringTest);
+public: 
+    UNIT_TEST_SUITE(TStringTest); 
     UNIT_TEST(TestMaxSize);
     UNIT_TEST(TestConstructors);
     UNIT_TEST(TestReplace);
@@ -752,7 +752,7 @@ public:
     UNIT_TEST(TestFillingAssign)
     UNIT_TEST(TestStdStreamApi)
     //UNIT_TEST(TestOperatorsCI); must fail
-    UNIT_TEST_SUITE_END();
+    UNIT_TEST_SUITE_END(); 
 
     void TestAppendUtf16() {
         TString appended = TString("А роза упала").AppendUtf16(u" на лапу Азора");
@@ -779,13 +779,13 @@ public:
         ss >> read;
         UNIT_ASSERT_VALUES_EQUAL(read, data);
     }
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TStringTest);
-
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TStringTest); 
+ 
 class TWideStringTest: public TTestBase, private TStringTestImpl<TUtf16String, TTestData<wchar16>> {
-public:
-    UNIT_TEST_SUITE(TWideStringTest);
+public: 
+    UNIT_TEST_SUITE(TWideStringTest); 
     UNIT_TEST(TestConstructors);
     UNIT_TEST(TestReplace);
 #ifndef TSTRING_IS_STD_STRING
@@ -812,7 +812,7 @@ public:
     UNIT_TEST(TestIterators);
     UNIT_TEST(TestReverseIterators);
     UNIT_TEST(TestStringLiterals);
-    UNIT_TEST_SUITE_END();
+    UNIT_TEST_SUITE_END(); 
 
 private:
     void TestDecodingMethods() {
@@ -903,10 +903,10 @@ private:
         TUtf16String s2 = u"привет";
         UNIT_ASSERT_VALUES_EQUAL(s2, TUtf16String::FromUtf8("привет"));
     }
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TWideStringTest);
-
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TWideStringTest); 
+ 
 class TUtf32StringTest: public TTestBase, private TStringTestImpl<TUtf32String, TTestData<wchar32>> {
 public:
     UNIT_TEST_SUITE(TUtf32StringTest);
@@ -1106,8 +1106,8 @@ private:
 UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest);
 
 class TStringStdTest: public TTestBase, private TStringStdTestImpl<TString, TTestData<char>> {
-public:
-    UNIT_TEST_SUITE(TStringStdTest);
+public: 
+    UNIT_TEST_SUITE(TStringStdTest); 
     UNIT_TEST(Constructor);
     UNIT_TEST(reserve);
     UNIT_TEST(short_string);
@@ -1131,19 +1131,19 @@ public:
     UNIT_TEST(cbegin_cend);
     UNIT_TEST(compare);
     UNIT_TEST(find_last_of);
-#if 0
-        UNIT_TEST(rfind);
-        UNIT_TEST(replace);
-#endif
+#if 0 
+        UNIT_TEST(rfind); 
+        UNIT_TEST(replace); 
+#endif 
     UNIT_TEST(find_last_not_of);
-    UNIT_TEST_SUITE_END();
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TStringStdTest);
-
+    UNIT_TEST_SUITE_END(); 
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TStringStdTest); 
+ 
 class TWideStringStdTest: public TTestBase, private TStringStdTestImpl<TUtf16String, TTestData<wchar16>> {
-public:
-    UNIT_TEST_SUITE(TWideStringStdTest);
+public: 
+    UNIT_TEST_SUITE(TWideStringStdTest); 
     UNIT_TEST(Constructor);
     UNIT_TEST(reserve);
     UNIT_TEST(short_string);
@@ -1167,15 +1167,15 @@ public:
     UNIT_TEST(cbegin_cend);
     UNIT_TEST(compare);
     UNIT_TEST(find_last_of);
-#if 0
-        UNIT_TEST(rfind);
-        UNIT_TEST(replace);
-#endif
+#if 0 
+        UNIT_TEST(rfind); 
+        UNIT_TEST(replace); 
+#endif 
     UNIT_TEST(find_last_not_of);
-    UNIT_TEST_SUITE_END();
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest);
+    UNIT_TEST_SUITE_END(); 
+}; 
+ 
+UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest); 
 
 Y_UNIT_TEST_SUITE(TStringConversionTest) {
     Y_UNIT_TEST(ConversionToStdStringTest) {
diff --git a/util/generic/string_ut.h b/util/generic/string_ut.h
index 44bb10bdeb..af517d8359 100644
--- a/util/generic/string_ut.h
+++ b/util/generic/string_ut.h
@@ -514,9 +514,9 @@ protected:
     using char_type = typename TStringType::char_type;
     using traits_type = typename TStringType::traits_type;
 
-    TTestData Data;
+    TTestData Data; 
 
-public:
+public: 
     void TestMaxSize() {
         const size_t badMaxVal = TStringType{}.max_size() + 1;
 
@@ -532,7 +532,7 @@ public:
         TStringType s;
         TStringType s1(*Data._0());
         TStringType s2(Data._0());
-        UNIT_ASSERT(s1 == s2);
+        UNIT_ASSERT(s1 == s2); 
 
         TStringType fromZero(0);
         UNIT_ASSERT_VALUES_EQUAL(fromZero.size(), 0u);
@@ -547,21 +547,21 @@ public:
 #endif
 
         TStringType s4(Data._0123456(), 1, 3);
-        UNIT_ASSERT(s4 == Data._123());
+        UNIT_ASSERT(s4 == Data._123()); 
 
         TStringType s5(5, *Data._0());
-        UNIT_ASSERT(s5 == Data._00000());
+        UNIT_ASSERT(s5 == Data._00000()); 
 
         TStringType s6(Data._0123456());
-        UNIT_ASSERT(s6 == Data._0123456());
+        UNIT_ASSERT(s6 == Data._0123456()); 
         TStringType s7(s6);
-        UNIT_ASSERT(s7 == s6);
+        UNIT_ASSERT(s7 == s6); 
 #ifndef TSTRING_IS_STD_STRING
-        UNIT_ASSERT(s7.c_str() == s6.c_str());
+        UNIT_ASSERT(s7.c_str() == s6.c_str()); 
 #endif
 
         TStringType s8(s7, 1, 3);
-        UNIT_ASSERT(s8 == Data._123());
+        UNIT_ASSERT(s8 == Data._123()); 
 
         TStringType s9(*Data._1());
         UNIT_ASSERT(s9 == Data._1());
@@ -569,86 +569,86 @@ public:
         TStringType s10(Reserve(100));
         UNIT_ASSERT(s10.empty());
         UNIT_ASSERT(s10.capacity() >= 100);
-    }
+    } 
 
     void TestReplace() {
         TStringType s(Data._0123456());
-        UNIT_ASSERT(s.copy() == Data._0123456());
+        UNIT_ASSERT(s.copy() == Data._0123456()); 
 
-        // append family
-        s.append(Data.x());
-        UNIT_ASSERT(s == Data._0123456x());
+        // append family 
+        s.append(Data.x()); 
+        UNIT_ASSERT(s == Data._0123456x()); 
 
 #ifdef TSTRING_IS_STD_STRING
         s.append(Data.xyz() + 1, 1);
 #else
-        s.append(Data.xyz(), 1, 1);
+        s.append(Data.xyz(), 1, 1); 
 #endif
-        UNIT_ASSERT(s == Data._0123456xy());
+        UNIT_ASSERT(s == Data._0123456xy()); 
 
         s.append(TStringType(Data.z()));
-        UNIT_ASSERT(s == Data._0123456xyz());
+        UNIT_ASSERT(s == Data._0123456xyz()); 
 
         s.append(TStringType(Data.XYZ()), 2, 1);
-        UNIT_ASSERT(s == Data._0123456xyzZ());
+        UNIT_ASSERT(s == Data._0123456xyzZ()); 
 
-        s.append(*Data._0());
-        UNIT_ASSERT(s == Data._0123456xyzZ0());
+        s.append(*Data._0()); 
+        UNIT_ASSERT(s == Data._0123456xyzZ0()); 
 
-        // prepend family
-        s = Data._0123456xyz();
+        // prepend family 
+        s = Data._0123456xyz(); 
         s.prepend(TStringType(Data.abc()));
-        UNIT_ASSERT(s == Data.abc0123456xyz());
+        UNIT_ASSERT(s == Data.abc0123456xyz()); 
 
         s.prepend(TStringType(Data.ABC()), 1, 2);
-        UNIT_ASSERT(s == Data.BCabc0123456xyz());
+        UNIT_ASSERT(s == Data.BCabc0123456xyz()); 
 
-        s.prepend(Data.qwe());
-        UNIT_ASSERT(s == Data.qweBCabc0123456xyz());
+        s.prepend(Data.qwe()); 
+        UNIT_ASSERT(s == Data.qweBCabc0123456xyz()); 
 
-        s.prepend(*Data._1());
-        UNIT_ASSERT(s == Data._1qweBCabc0123456xyz());
+        s.prepend(*Data._1()); 
+        UNIT_ASSERT(s == Data._1qweBCabc0123456xyz()); 
 
-        // substr
-        s = Data.abc0123456xyz();
-        s = s.substr(3, 7);
-        UNIT_ASSERT(s == Data._0123456());
+        // substr 
+        s = Data.abc0123456xyz(); 
+        s = s.substr(3, 7); 
+        UNIT_ASSERT(s == Data._0123456()); 
 
-        // insert family
-        s.insert(2, Data.abc());
-        UNIT_ASSERT(s == Data._01abc23456());
+        // insert family 
+        s.insert(2, Data.abc()); 
+        UNIT_ASSERT(s == Data._01abc23456()); 
 
         s.insert(2, TStringType(Data.ABC()));
-        UNIT_ASSERT(s == Data._01ABCabc23456());
+        UNIT_ASSERT(s == Data._01ABCabc23456()); 
 
         s.insert(0, TStringType(Data.QWE()), 1, 1);
-        UNIT_ASSERT(s == Data.W01ABCabc23456());
+        UNIT_ASSERT(s == Data.W01ABCabc23456()); 
 
-        // replace family
-        s = Data._01abc23456();
-        s.replace(0, 7, Data.abcd());
-        UNIT_ASSERT(s == Data.abcd456());
+        // replace family 
+        s = Data._01abc23456(); 
+        s.replace(0, 7, Data.abcd()); 
+        UNIT_ASSERT(s == Data.abcd456()); 
 
         s.replace(4, 3, TStringType(Data.ABCD()));
-        UNIT_ASSERT(s == Data.abcdABCD());
+        UNIT_ASSERT(s == Data.abcdABCD()); 
 
         s.replace(7, 10, TStringType(Data._01234()), 1, 3);
-        UNIT_ASSERT(s == Data.abcdABC123());
-        UNIT_ASSERT(Data.abcdABC123() == s);
-
-        // remove, erase
-        s.remove(4);
-        UNIT_ASSERT(s == Data.abcd());
-        s.erase(3);
-        UNIT_ASSERT(s == Data.abc());
-
-        // Read access
-        s = Data._012345();
-        UNIT_ASSERT(s.at(1) == *Data._1());
-        UNIT_ASSERT(s[1] == *Data._1());
+        UNIT_ASSERT(s == Data.abcdABC123()); 
+        UNIT_ASSERT(Data.abcdABC123() == s); 
+
+        // remove, erase 
+        s.remove(4); 
+        UNIT_ASSERT(s == Data.abcd()); 
+        s.erase(3); 
+        UNIT_ASSERT(s == Data.abc()); 
+
+        // Read access 
+        s = Data._012345(); 
+        UNIT_ASSERT(s.at(1) == *Data._1()); 
+        UNIT_ASSERT(s[1] == *Data._1()); 
         UNIT_ASSERT(s.at(s.size()) == 0);
         UNIT_ASSERT(s[s.size()] == 0);
-    }
+    } 
 
 #ifndef TSTRING_IS_STD_STRING
     void TestRefCount() {
@@ -658,47 +658,47 @@ public:
             using TStr::TStr;
             // un-protect
             using TStr::RefCount;
-        };
-
-        TestStroka s1(Data.orig());
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true);
-        TestStroka s2(s1);
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 2, true);
-        UNIT_ASSERT_EQUAL(s2.RefCount() == 2, true);
-        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), true); // the same pointer
-        char_type* beg = s2.begin();
-        UNIT_ASSERT_EQUAL(s1 == beg, true);
-        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true);
-        UNIT_ASSERT_EQUAL(s2.RefCount() == 1, true);
-        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), false);
-    }
+        }; 
+
+        TestStroka s1(Data.orig()); 
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true); 
+        TestStroka s2(s1); 
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 2, true); 
+        UNIT_ASSERT_EQUAL(s2.RefCount() == 2, true); 
+        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), true); // the same pointer 
+        char_type* beg = s2.begin(); 
+        UNIT_ASSERT_EQUAL(s1 == beg, true); 
+        UNIT_ASSERT_EQUAL(s1.RefCount() == 1, true); 
+        UNIT_ASSERT_EQUAL(s2.RefCount() == 1, true); 
+        UNIT_ASSERT_EQUAL(s1.c_str() == s2.c_str(), false); 
+    } 
 #endif
 
-    //  Find family
+    //  Find family 
 
     void TestFind() {
         const TStringType s(Data._0123456_12345());
         const TStringType s2(Data._0123());
 
-        UNIT_ASSERT(s.find(Data._345()) == 3);
-        UNIT_ASSERT(s.find(Data._345(), 5) == 10);
+        UNIT_ASSERT(s.find(Data._345()) == 3); 
+        UNIT_ASSERT(s.find(Data._345(), 5) == 10); 
 
         UNIT_ASSERT(s.find(Data._345(), 20) == TStringType::npos);
-        UNIT_ASSERT(s.find(*Data._3()) == 3);
+        UNIT_ASSERT(s.find(*Data._3()) == 3); 
         UNIT_ASSERT(s.find(TStringType(Data._345())) == 3);
         UNIT_ASSERT(s.find(TStringType(Data._345()), 2) == 3);
 
         UNIT_ASSERT(s.find_first_of(TStringType(Data._389())) == 3);
-        UNIT_ASSERT(s.find_first_of(Data._389()) == 3);
+        UNIT_ASSERT(s.find_first_of(Data._389()) == 3); 
         UNIT_ASSERT(s.find_first_of(Data._389(), s.size()) == TStringType::npos);
-        UNIT_ASSERT(s.find_first_not_of(Data._123()) == 0);
+        UNIT_ASSERT(s.find_first_not_of(Data._123()) == 0); 
         UNIT_ASSERT(s.find_first_of('6') == 6);
         UNIT_ASSERT(s.find_first_of('1', 2) == 8);
         UNIT_ASSERT(s.find_first_not_of('0') == 1);
         UNIT_ASSERT(s.find_first_not_of('1', 1) == 2);
 
         const TStringType rs = Data._0123401234();
-        UNIT_ASSERT(rs.rfind(*Data._3()) == 8);
+        UNIT_ASSERT(rs.rfind(*Data._3()) == 8); 
 
         const TStringType empty;
         UNIT_ASSERT(empty.find(empty) == 0);
@@ -739,58 +739,58 @@ public:
         UNIT_ASSERT(s.Contains(empty, s.length()));
     }
 
-    // Operators
+    // Operators 
 
     void TestOperators() {
         TStringType s(Data._0123456());
 
-        // operator +=
+        // operator += 
         s += TStringType(Data.x());
-        UNIT_ASSERT(s == Data._0123456x());
+        UNIT_ASSERT(s == Data._0123456x()); 
 
-        s += Data.y();
-        UNIT_ASSERT(s == Data._0123456xy());
+        s += Data.y(); 
+        UNIT_ASSERT(s == Data._0123456xy()); 
 
-        s += *Data.z();
-        UNIT_ASSERT(s == Data._0123456xyz());
+        s += *Data.z(); 
+        UNIT_ASSERT(s == Data._0123456xyz()); 
 
-        // operator +
-        s = Data._0123456();
+        // operator + 
+        s = Data._0123456(); 
         s = s + TStringType(Data.x());
-        UNIT_ASSERT(s == Data._0123456x());
+        UNIT_ASSERT(s == Data._0123456x()); 
 
-        s = s + Data.y();
-        UNIT_ASSERT(s == Data._0123456xy());
+        s = s + Data.y(); 
+        UNIT_ASSERT(s == Data._0123456xy()); 
 
-        s = s + *Data.z();
-        UNIT_ASSERT(s == Data._0123456xyz());
+        s = s + *Data.z(); 
+        UNIT_ASSERT(s == Data._0123456xyz()); 
 
-        // operator !=
-        s = Data._012345();
+        // operator != 
+        s = Data._012345(); 
         UNIT_ASSERT(s != TStringType(Data.xyz()));
-        UNIT_ASSERT(s != Data.xyz());
-        UNIT_ASSERT(Data.xyz() != s);
+        UNIT_ASSERT(s != Data.xyz()); 
+        UNIT_ASSERT(Data.xyz() != s); 
 
-        // operator <
+        // operator < 
         UNIT_ASSERT_EQUAL(s < TStringType(Data.xyz()), true);
-        UNIT_ASSERT_EQUAL(s < Data.xyz(), true);
-        UNIT_ASSERT_EQUAL(Data.xyz() < s, false);
+        UNIT_ASSERT_EQUAL(s < Data.xyz(), true); 
+        UNIT_ASSERT_EQUAL(Data.xyz() < s, false); 
 
-        // operator <=
+        // operator <= 
         UNIT_ASSERT_EQUAL(s <= TStringType(Data.xyz()), true);
-        UNIT_ASSERT_EQUAL(s <= Data.xyz(), true);
-        UNIT_ASSERT_EQUAL(Data.xyz() <= s, false);
+        UNIT_ASSERT_EQUAL(s <= Data.xyz(), true); 
+        UNIT_ASSERT_EQUAL(Data.xyz() <= s, false); 
 
-        // operator >
+        // operator > 
         UNIT_ASSERT_EQUAL(s > TStringType(Data.xyz()), false);
-        UNIT_ASSERT_EQUAL(s > Data.xyz(), false);
-        UNIT_ASSERT_EQUAL(Data.xyz() > s, true);
+        UNIT_ASSERT_EQUAL(s > Data.xyz(), false); 
+        UNIT_ASSERT_EQUAL(Data.xyz() > s, true); 
 
-        // operator >=
+        // operator >= 
         UNIT_ASSERT_EQUAL(s >= TStringType(Data.xyz()), false);
-        UNIT_ASSERT_EQUAL(s >= Data.xyz(), false);
-        UNIT_ASSERT_EQUAL(Data.xyz() >= s, true);
-    }
+        UNIT_ASSERT_EQUAL(s >= Data.xyz(), false); 
+        UNIT_ASSERT_EQUAL(Data.xyz() >= s, true); 
+    } 
 
     void TestOperatorsCI() {
         TStringType s(Data.ABCD());
@@ -805,132 +805,132 @@ public:
     }
 
     void TestMulOperators() {
-        {
+        { 
             TStringType s(Data._0());
-            s *= 10;
+            s *= 10; 
             UNIT_ASSERT_EQUAL(s, TStringType(Data._0000000000()));
-        }
-        {
+        } 
+        { 
             TStringType s = TStringType(Data._0()) * 2;
             UNIT_ASSERT_EQUAL(s, TStringType(Data._00()));
-        }
-    }
+        } 
+    } 
 
-    // Test any other functions
+    // Test any other functions 
 
     void TestFuncs() {
         TStringType s(Data._0123456());
         UNIT_ASSERT(s.c_str() == s.data());
 
-        // length()
+        // length() 
         UNIT_ASSERT(s.length() == s.size());
         UNIT_ASSERT(s.length() == traits_type::length(s.data()));
 
-        // is_null()
+        // is_null() 
         TStringType s1(Data.Empty());
-        UNIT_ASSERT(s1.is_null() == true);
-        UNIT_ASSERT(s1.is_null() == s1.empty());
-        UNIT_ASSERT(s1.is_null() == !s1);
+        UNIT_ASSERT(s1.is_null() == true); 
+        UNIT_ASSERT(s1.is_null() == s1.empty()); 
+        UNIT_ASSERT(s1.is_null() == !s1); 
 
         TStringType s2(s);
-        UNIT_ASSERT(s2 == s);
+        UNIT_ASSERT(s2 == s); 
 
-        // reverse()
+        // reverse() 
         ReverseInPlace(s2);
-        UNIT_ASSERT(s2 == Data._6543210());
+        UNIT_ASSERT(s2 == Data._6543210()); 
 
-        // to_upper()
-        s2 = Data.asdf1234qwer();
-        s2.to_upper();
-        UNIT_ASSERT(s2 == Data.ASDF1234QWER());
+        // to_upper() 
+        s2 = Data.asdf1234qwer(); 
+        s2.to_upper(); 
+        UNIT_ASSERT(s2 == Data.ASDF1234QWER()); 
 
-        // to_lower()
-        s2.to_lower();
-        UNIT_ASSERT(s2 == Data.asdf1234qwer());
+        // to_lower() 
+        s2.to_lower(); 
+        UNIT_ASSERT(s2 == Data.asdf1234qwer()); 
 
-        // to_title()
-        s2 = Data.asDF1234qWEr();
-        s2.to_title();
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
+        // to_title() 
+        s2 = Data.asDF1234qWEr(); 
+        s2.to_title(); 
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
 
-        s2 = Data.AsDF1234qWEr();
-        s2.to_title();
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
+        s2 = Data.AsDF1234qWEr(); 
+        s2.to_title(); 
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
 
-        // Friend functions
-        s2 = Data.asdf1234qwer();
+        // Friend functions 
+        s2 = Data.asdf1234qwer(); 
         TStringType s3 = to_upper(s2);
-        UNIT_ASSERT(s3 == Data.ASDF1234QWER());
-        s3 = to_lower(s2);
-        UNIT_ASSERT(s3 == Data.asdf1234qwer());
-        s3 = to_title(s2);
-        UNIT_ASSERT(s3 == Data.Asdf1234qwer());
-        s2 = s3;
-
-        // resize family
+        UNIT_ASSERT(s3 == Data.ASDF1234QWER()); 
+        s3 = to_lower(s2); 
+        UNIT_ASSERT(s3 == Data.asdf1234qwer()); 
+        s3 = to_title(s2); 
+        UNIT_ASSERT(s3 == Data.Asdf1234qwer()); 
+        s2 = s3; 
+
+        // resize family 
         s2.resize(s2.size()); // without length change
-        UNIT_ASSERT(s2 == Data.Asdf1234qwer());
+        UNIT_ASSERT(s2 == Data.Asdf1234qwer()); 
 
         s2.resize(s2.size() + 4, *Data.W());
-        UNIT_ASSERT(s2 == Data.Asdf1234qwerWWWW());
+        UNIT_ASSERT(s2 == Data.Asdf1234qwerWWWW()); 
 
-        s2.resize(4);
-        UNIT_ASSERT(s2 == Data.Asdf());
+        s2.resize(4); 
+        UNIT_ASSERT(s2 == Data.Asdf()); 
 
-        // assign family
-        s2 = Data.asdf1234qwer();
-        s2.assign(s, 1, 3);
-        UNIT_ASSERT(s2 == Data._123());
+        // assign family 
+        s2 = Data.asdf1234qwer(); 
+        s2.assign(s, 1, 3); 
+        UNIT_ASSERT(s2 == Data._123()); 
 
-        s2.assign(Data._0123456(), 4);
-        UNIT_ASSERT(s2 == Data._0123());
+        s2.assign(Data._0123456(), 4); 
+        UNIT_ASSERT(s2 == Data._0123()); 
 
         s2.assign('1');
         UNIT_ASSERT(s2 == Data._1());
 
-        s2.assign(Data._0123456());
-        UNIT_ASSERT(s2 == Data._0123456());
+        s2.assign(Data._0123456()); 
+        UNIT_ASSERT(s2 == Data._0123456()); 
 
-        // hash()
+        // hash() 
         TStringType sS = s2; // type 'TStringType' is used as is
 
         ComputeHash(sS); /*size_t hash_val = sS.hash();
 
         try {
             //UNIT_ASSERT(hash_val == Data.HashOf_0123456());
-        } catch (...) {
-            Cerr << hash_val << Endl;
-            throw;
+        } catch (...) { 
+            Cerr << hash_val << Endl; 
+            throw; 
         }*/
 
-        s2.assign(Data._0123456(), 2, 2);
-        UNIT_ASSERT(s2 == Data._23());
+        s2.assign(Data._0123456(), 2, 2); 
+        UNIT_ASSERT(s2 == Data._23()); 
 
-        //s2.reserve();
+        //s2.reserve(); 
 
         TStringType s5(Data.abcde());
         s5.clear();
-        UNIT_ASSERT(s5 == Data.Empty());
-    }
+        UNIT_ASSERT(s5 == Data.Empty()); 
+    } 
 
     void TestUtils() {
         TStringType s;
-        s = Data._01230123();
+        s = Data._01230123(); 
         TStringType from = Data._0();
         TStringType to = Data.z();
 
         SubstGlobal(s, from, to);
-        UNIT_ASSERT(s == Data.z123z123());
-    }
+        UNIT_ASSERT(s == Data.z123z123()); 
+    } 
 
     void TestEmpty() {
         TStringType s;
-        s = Data._2();
+        s = Data._2(); 
         s = TStringType(Data.fdfdsfds(), (size_t)0, (size_t)0);
-        UNIT_ASSERT(s.empty());
-    }
+        UNIT_ASSERT(s.empty()); 
+    } 
 
-    void TestJoin() {
+    void TestJoin() { 
         UNIT_ASSERT_EQUAL(TStringType::Join(Data._12(), Data._3456()), Data._123456());
         UNIT_ASSERT_EQUAL(TStringType::Join(Data._12(), TStringType(Data._3456())), Data._123456());
         UNIT_ASSERT_EQUAL(TStringType::Join(TStringType(Data._12()), Data._3456()), Data._123456());
@@ -941,43 +941,43 @@ public:
         UNIT_ASSERT_EQUAL(TStringType::Join(TStringType(Data.a()), static_cast<typename TStringType::char_type>('b'), TStringType(Data.cd()), TStringType(Data.e()), Data.fg(), TStringType(Data.h())), Data.abcdefgh());
     }
 
-    void TestCopy() {
+    void TestCopy() { 
         TStringType s(Data.abcd());
         TStringType c = s.copy();
 
-        UNIT_ASSERT_EQUAL(s, c);
-        UNIT_ASSERT(s.end() != c.end());
-    }
+        UNIT_ASSERT_EQUAL(s, c); 
+        UNIT_ASSERT(s.end() != c.end()); 
+    } 
 
-    void TestStrCpy() {
-        {
+    void TestStrCpy() { 
+        { 
             TStringType s(Data.abcd());
-            char_type data[5];
+            char_type data[5]; 
 
-            data[4] = 1;
+            data[4] = 1; 
 
-            s.strcpy(data, 4);
+            s.strcpy(data, 4); 
 
-            UNIT_ASSERT_EQUAL(data[0], *Data.a());
-            UNIT_ASSERT_EQUAL(data[1], *Data.b());
-            UNIT_ASSERT_EQUAL(data[2], *Data.c());
-            UNIT_ASSERT_EQUAL(data[3], 0);
-            UNIT_ASSERT_EQUAL(data[4], 1);
-        }
+            UNIT_ASSERT_EQUAL(data[0], *Data.a()); 
+            UNIT_ASSERT_EQUAL(data[1], *Data.b()); 
+            UNIT_ASSERT_EQUAL(data[2], *Data.c()); 
+            UNIT_ASSERT_EQUAL(data[3], 0); 
+            UNIT_ASSERT_EQUAL(data[4], 1); 
+        } 
 
-        {
+        { 
             TStringType s(Data.abcd());
-            char_type data[5];
-
-            s.strcpy(data, 5);
-
-            UNIT_ASSERT_EQUAL(data[0], *Data.a());
-            UNIT_ASSERT_EQUAL(data[1], *Data.b());
-            UNIT_ASSERT_EQUAL(data[2], *Data.c());
-            UNIT_ASSERT_EQUAL(data[3], *Data.d());
-            UNIT_ASSERT_EQUAL(data[4], 0);
-        }
-    }
+            char_type data[5]; 
+ 
+            s.strcpy(data, 5); 
+ 
+            UNIT_ASSERT_EQUAL(data[0], *Data.a()); 
+            UNIT_ASSERT_EQUAL(data[1], *Data.b()); 
+            UNIT_ASSERT_EQUAL(data[2], *Data.c()); 
+            UNIT_ASSERT_EQUAL(data[3], *Data.d()); 
+            UNIT_ASSERT_EQUAL(data[4], 0); 
+        } 
+    } 
 
     void TestPrefixSuffix() {
         const TStringType emptyStr;
@@ -1153,4 +1153,4 @@ public:
         *ritBegin = (ui8)'e';
         UNIT_ASSERT_VALUES_EQUAL(*ritBegin, (ui8)'e');
     }
-};
+}; 
diff --git a/util/generic/yexception_ut.c b/util/generic/yexception_ut.c
index 3880c82e29..a46ae5b783 100644
--- a/util/generic/yexception_ut.c
+++ b/util/generic/yexception_ut.c
@@ -1,5 +1,5 @@
-#include "yexception_ut.h"
-
-void TestCallback(TCallbackFun f, int i) {
-    f(i);
-}
+#include "yexception_ut.h" 
+ 
+void TestCallback(TCallbackFun f, int i) { 
+    f(i); 
+} 
diff --git a/util/generic/yexception_ut.cpp b/util/generic/yexception_ut.cpp
index cb3e29fed8..6feb5c65c0 100644
--- a/util/generic/yexception_ut.cpp
+++ b/util/generic/yexception_ut.cpp
@@ -16,17 +16,17 @@ static inline void Throw2DontMove() {
 #include <util/stream/output.h>
 #include <util/string/subst.h>
 
-#include "yexception_ut.h"
+#include "yexception_ut.h" 
 #include "bt_exception.h"
-
+ 
 #if defined(_MSC_VER)
     #pragma warning(disable : 4702) /*unreachable code*/
 #endif
 
-static void CallbackFun(int i) {
-    throw i;
-}
-
+static void CallbackFun(int i) { 
+    throw i; 
+} 
+ 
 static IOutputStream* OUTS = nullptr;
 
 namespace NOuter::NInner {
@@ -247,7 +247,7 @@ private:
             throw;
         }
     }
-
+ 
     //! tests propagation of an exception through C code
     //! @note on some platforms, for example GCC on 32-bit Linux without -fexceptions option,
     //!       throwing an exception from a C++ callback through C code aborts program
@@ -258,7 +258,7 @@ private:
             UNIT_ASSERT(false);
         } catch (int i) {
             UNIT_ASSERT_VALUES_EQUAL(i, N);
-        }
+        } 
     }
 
     void TestMacroOverload() {
diff --git a/util/generic/yexception_ut.h b/util/generic/yexception_ut.h
index acf6f27e99..6b5ce34f34 100644
--- a/util/generic/yexception_ut.h
+++ b/util/generic/yexception_ut.h
@@ -1,14 +1,14 @@
 #pragma once
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
+ 
+#ifdef __cplusplus 
+extern "C" { 
+#endif 
+ 
     typedef void (*TCallbackFun)(int);
-
+ 
     //! just calls callback with parameter @c i
     void TestCallback(TCallbackFun f, int i);
-
-#ifdef __cplusplus
-}
-#endif
+ 
+#ifdef __cplusplus 
+} 
+#endif