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

5 files changed, 409 insertions, 409 deletions

diff --git a/library/cpp/actors/testlib/decorator_ut.cpp b/library/cpp/actors/testlib/decorator_ut.cpp
index cc937080da..e9a2fa3560 100644
--- a/library/cpp/actors/testlib/decorator_ut.cpp
+++ b/library/cpp/actors/testlib/decorator_ut.cpp
@@ -1,327 +1,327 @@
-#include "test_runtime.h" 
- 
-#include <library/cpp/actors/core/actor_bootstrapped.h> 
-#include <library/cpp/testing/unittest/registar.h> 
- 
- 
-using namespace NActors; 
- 
- 
-Y_UNIT_TEST_SUITE(TesTTestDecorator) { 
- 
-    bool IsVerbose = false; 
-    void Write(TString msg) { 
-        if (IsVerbose) { 
-            Cerr << (TStringBuilder() << msg << Endl); 
-        } 
-    } 
- 
-    struct TDyingChecker : TTestDecorator { 
-        TActorId MasterId; 
- 
-        TDyingChecker(THolder<IActor> &&actor, TActorId masterId) 
-            : TTestDecorator(std::move(actor)) 
-            , MasterId(masterId) 
-        { 
-            Write("TDyingChecker::Construct\n"); 
-        } 
- 
-        virtual ~TDyingChecker() { 
-            Write("TDyingChecker::~TDyingChecker"); 
-            TActivationContext::Send(new IEventHandle(MasterId, SelfId(), new TEvents::TEvPing())); 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TDyingChecker::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TDyingChecker::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TTestMasterActor : TActorBootstrapped<TTestMasterActor> { 
-        friend TActorBootstrapped<TTestMasterActor>; 
- 
-        TSet<TActorId> ActorIds; 
-        TVector<THolder<IActor>> Actors; 
-        TActorId EdgeActor; 
-         
-        TTestMasterActor(TVector<THolder<IActor>> &&actors, TActorId edgeActor) 
-            : TActorBootstrapped() 
-            , Actors(std::move(actors)) 
-            , EdgeActor(edgeActor) 
-        { 
-        } 
- 
-        void Bootstrap() 
-        { 
-            Write("Start master actor"); 
-            for (auto &actor : Actors) { 
+#include "test_runtime.h"
+
+#include <library/cpp/actors/core/actor_bootstrapped.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+
+using namespace NActors;
+
+
+Y_UNIT_TEST_SUITE(TesTTestDecorator) {
+
+    bool IsVerbose = false;
+    void Write(TString msg) {
+        if (IsVerbose) {
+            Cerr << (TStringBuilder() << msg << Endl);
+        }
+    }
+
+    struct TDyingChecker : TTestDecorator {
+        TActorId MasterId;
+
+        TDyingChecker(THolder<IActor> &&actor, TActorId masterId)
+            : TTestDecorator(std::move(actor))
+            , MasterId(masterId)
+        {
+            Write("TDyingChecker::Construct\n");
+        }
+
+        virtual ~TDyingChecker() {
+            Write("TDyingChecker::~TDyingChecker");
+            TActivationContext::Send(new IEventHandle(MasterId, SelfId(), new TEvents::TEvPing()));
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TDyingChecker::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TDyingChecker::DoAfterReceiving");
+        }
+    };
+
+    struct TTestMasterActor : TActorBootstrapped<TTestMasterActor> {
+        friend TActorBootstrapped<TTestMasterActor>;
+
+        TSet<TActorId> ActorIds;
+        TVector<THolder<IActor>> Actors;
+        TActorId EdgeActor;
+        
+        TTestMasterActor(TVector<THolder<IActor>> &&actors, TActorId edgeActor)
+            : TActorBootstrapped()
+            , Actors(std::move(actors))
+            , EdgeActor(edgeActor)
+        {
+        }
+
+        void Bootstrap()
+        {
+            Write("Start master actor");
+            for (auto &actor : Actors) {
                 THolder<IActor> decaratedActor = MakeHolder<TDyingChecker>(std::move(actor), SelfId());
-                TActorId id = Register(decaratedActor.Release()); 
-                Write("Register test actor"); 
-                UNIT_ASSERT(ActorIds.insert(id).second); 
-            } 
-            Become(&TTestMasterActor::State); 
-        } 
- 
-        STATEFN(State) { 
-            auto it = ActorIds.find(ev->Sender); 
-            UNIT_ASSERT(it != ActorIds.end()); 
-            Write("End test actor"); 
-            ActorIds.erase(it); 
-            if (!ActorIds) { 
-                Send(EdgeActor, new TEvents::TEvPing()); 
-                PassAway(); 
-            } 
-        } 
-    }; 
- 
-    enum { 
-        Begin = EventSpaceBegin(TEvents::ES_USERSPACE), 
-        EvWords 
-    }; 
- 
-    struct TEvWords : TEventLocal<TEvWords, EvWords> { 
-        TVector<TString> Words; 
- 
-        TEvWords() 
-            : TEventLocal() 
-        { 
-        } 
-    }; 
- 
-    struct TFizzBuzzToFooBar : TTestDecorator { 
-        TFizzBuzzToFooBar(THolder<IActor> &&actor) 
-            : TTestDecorator(std::move(actor)) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TFizzBuzzToFooBar::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            TStringBuilder wordsMsg; 
-            for (auto &word : words) { 
-                wordsMsg << word << ';'; 
-            } 
-            Write(TStringBuilder() << "Send# " << wordsMsg); 
-            if (words.size() == 2 && words[0] == "Fizz" && words[1] == "Buzz") { 
-                words[0] = "Foo"; 
-                words[1] = "Bar"; 
-            } 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TFizzBuzzToFooBar::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TFizzBuzzToFooBar::DoAfterReceiving"); 
-        } 
-    };     
-     
-    struct TWordEraser : TTestDecorator { 
-        TString ErasingWord; 
- 
-        TWordEraser(THolder<IActor> &&actor, TString word) 
-            : TTestDecorator(std::move(actor)) 
-            , ErasingWord(word) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TWordEraser::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            auto it = Find(words.begin(), words.end(), ErasingWord); 
-            if (it != words.end()) { 
-                words.erase(it); 
-            } 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TWordEraser::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TWordEraser::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TWithoutWordsDroper : TTestDecorator { 
-        TWithoutWordsDroper(THolder<IActor> &&actor) 
-            : TTestDecorator(std::move(actor)) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TWithoutWordsDroper::DoBeforeSending"); 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            TEvWords *event = handle->Get(); 
-            return bool(event->Words); 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TWithoutWordsDroper::DoBeforeReceiving"); 
-            return true; 
-        } 
-         
-        void DoAfterReceiving(const TActorContext &/*ctx*/) override { 
-            Write("TWithoutWordsDroper::DoAfterReceiving"); 
-        } 
-    }; 
- 
-    struct TFooBarReceiver : TActorBootstrapped<TFooBarReceiver> { 
-        TActorId MasterId; 
-        ui64 Counter = 0; 
- 
-        TFooBarReceiver(TActorId masterId) 
-            : TActorBootstrapped() 
-            , MasterId(masterId) 
-        { 
-        } 
- 
-        void Bootstrap() 
-        { 
-            Become(&TFooBarReceiver::State); 
-        } 
- 
-        STATEFN(State) { 
-            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get()); 
-            UNIT_ASSERT(handle); 
-            UNIT_ASSERT(handle->Sender == MasterId); 
-            TEvWords *event = handle->Get(); 
-            TVector<TString> &words = event->Words; 
-            UNIT_ASSERT(words.size() == 2 && words[0] == "Foo" && words[1] == "Bar"); 
-            Write(TStringBuilder() << "Receive# " << Counter + 1 << '/' << 2); 
-            if (++Counter == 2) { 
-                PassAway(); 
-            } 
-        } 
-    }; 
- 
-    struct TFizzBuzzSender : TActorBootstrapped<TFizzBuzzSender> { 
-        TActorId SlaveId; 
- 
-        TFizzBuzzSender() 
-            : TActorBootstrapped() 
-        { 
-            Write("TFizzBuzzSender::Construct"); 
-        } 
- 
-        void Bootstrap() { 
-            Write("TFizzBuzzSender::Bootstrap"); 
+                TActorId id = Register(decaratedActor.Release());
+                Write("Register test actor");
+                UNIT_ASSERT(ActorIds.insert(id).second);
+            }
+            Become(&TTestMasterActor::State);
+        }
+
+        STATEFN(State) {
+            auto it = ActorIds.find(ev->Sender);
+            UNIT_ASSERT(it != ActorIds.end());
+            Write("End test actor");
+            ActorIds.erase(it);
+            if (!ActorIds) {
+                Send(EdgeActor, new TEvents::TEvPing());
+                PassAway();
+            }
+        }
+    };
+
+    enum {
+        Begin = EventSpaceBegin(TEvents::ES_USERSPACE),
+        EvWords
+    };
+
+    struct TEvWords : TEventLocal<TEvWords, EvWords> {
+        TVector<TString> Words;
+
+        TEvWords()
+            : TEventLocal()
+        {
+        }
+    };
+
+    struct TFizzBuzzToFooBar : TTestDecorator {
+        TFizzBuzzToFooBar(THolder<IActor> &&actor)
+            : TTestDecorator(std::move(actor))
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TFizzBuzzToFooBar::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            TStringBuilder wordsMsg;
+            for (auto &word : words) {
+                wordsMsg << word << ';';
+            }
+            Write(TStringBuilder() << "Send# " << wordsMsg);
+            if (words.size() == 2 && words[0] == "Fizz" && words[1] == "Buzz") {
+                words[0] = "Foo";
+                words[1] = "Bar";
+            }
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TFizzBuzzToFooBar::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TFizzBuzzToFooBar::DoAfterReceiving");
+        }
+    };    
+    
+    struct TWordEraser : TTestDecorator {
+        TString ErasingWord;
+
+        TWordEraser(THolder<IActor> &&actor, TString word)
+            : TTestDecorator(std::move(actor))
+            , ErasingWord(word)
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TWordEraser::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            auto it = Find(words.begin(), words.end(), ErasingWord);
+            if (it != words.end()) {
+                words.erase(it);
+            }
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TWordEraser::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TWordEraser::DoAfterReceiving");
+        }
+    };
+
+    struct TWithoutWordsDroper : TTestDecorator {
+        TWithoutWordsDroper(THolder<IActor> &&actor)
+            : TTestDecorator(std::move(actor))
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TWithoutWordsDroper::DoBeforeSending");
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            TEvWords *event = handle->Get();
+            return bool(event->Words);
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TWithoutWordsDroper::DoBeforeReceiving");
+            return true;
+        }
+        
+        void DoAfterReceiving(const TActorContext &/*ctx*/) override {
+            Write("TWithoutWordsDroper::DoAfterReceiving");
+        }
+    };
+
+    struct TFooBarReceiver : TActorBootstrapped<TFooBarReceiver> {
+        TActorId MasterId;
+        ui64 Counter = 0;
+
+        TFooBarReceiver(TActorId masterId)
+            : TActorBootstrapped()
+            , MasterId(masterId)
+        {
+        }
+
+        void Bootstrap()
+        {
+            Become(&TFooBarReceiver::State);
+        }
+
+        STATEFN(State) {
+            TEventHandle<TEvWords> *handle = reinterpret_cast<TEventHandle<TEvWords>*>(ev.Get());
+            UNIT_ASSERT(handle);
+            UNIT_ASSERT(handle->Sender == MasterId);
+            TEvWords *event = handle->Get();
+            TVector<TString> &words = event->Words;
+            UNIT_ASSERT(words.size() == 2 && words[0] == "Foo" && words[1] == "Bar");
+            Write(TStringBuilder() << "Receive# " << Counter + 1 << '/' << 2);
+            if (++Counter == 2) {
+                PassAway();
+            }
+        }
+    };
+
+    struct TFizzBuzzSender : TActorBootstrapped<TFizzBuzzSender> {
+        TActorId SlaveId;
+
+        TFizzBuzzSender()
+            : TActorBootstrapped()
+        {
+            Write("TFizzBuzzSender::Construct");
+        }
+
+        void Bootstrap() {
+            Write("TFizzBuzzSender::Bootstrap");
             THolder<IActor> actor = MakeHolder<TFooBarReceiver>(SelfId());
             THolder<IActor> decoratedActor = MakeHolder<TDyingChecker>(std::move(actor), SelfId());
-            SlaveId = Register(decoratedActor.Release()); 
-            for (ui64 idx = 1; idx <= 30; ++idx) { 
+            SlaveId = Register(decoratedActor.Release());
+            for (ui64 idx = 1; idx <= 30; ++idx) {
                 THolder<TEvWords> ev = MakeHolder<TEvWords>();
-                if (idx % 3 == 0) { 
-                    ev->Words.push_back("Fizz"); 
-                } 
-                if (idx % 5 == 0) { 
-                    ev->Words.push_back("Buzz"); 
-                } 
-                Send(SlaveId, ev.Release()); 
-                Write("TFizzBuzzSender::Send words"); 
-            } 
-            Become(&TFizzBuzzSender::State); 
-        } 
- 
-        STATEFN(State) { 
-            UNIT_ASSERT(ev->Sender == SlaveId); 
-            PassAway(); 
-        } 
-    }; 
- 
-    struct TCounters { 
-        ui64 SendedCount = 0; 
-        ui64 RecievedCount = 0; 
-    }; 
- 
-    struct TCountingDecorator : TTestDecorator { 
-        TCounters *Counters; 
- 
-        TCountingDecorator(THolder<IActor> &&actor, TCounters *counters) 
-            : TTestDecorator(std::move(actor)) 
-            , Counters(counters) 
-        { 
-        } 
- 
-        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override { 
-            if (ev->Type == TEvents::TSystem::Bootstrap) { 
-                return true; 
-            } 
-            Write("TCountingDecorator::DoBeforeSending"); 
-            Counters->SendedCount++; 
-            return true; 
-        } 
- 
-        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override { 
-            Write("TCountingDecorator::DoBeforeReceiving"); 
-            Counters->RecievedCount++; 
-            return true; 
-        } 
-    }; 
-     
-    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event, 
-            TDuration delay, TInstant& deadline) { 
-        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) { 
-            deadline = runtime.GetTimeProvider()->Now() + delay; 
-            return false; 
-        } 
-        return true; 
-    } 
- 
-    THolder<IActor> CreateFizzBuzzSender() { 
+                if (idx % 3 == 0) {
+                    ev->Words.push_back("Fizz");
+                }
+                if (idx % 5 == 0) {
+                    ev->Words.push_back("Buzz");
+                }
+                Send(SlaveId, ev.Release());
+                Write("TFizzBuzzSender::Send words");
+            }
+            Become(&TFizzBuzzSender::State);
+        }
+
+        STATEFN(State) {
+            UNIT_ASSERT(ev->Sender == SlaveId);
+            PassAway();
+        }
+    };
+
+    struct TCounters {
+        ui64 SendedCount = 0;
+        ui64 RecievedCount = 0;
+    };
+
+    struct TCountingDecorator : TTestDecorator {
+        TCounters *Counters;
+
+        TCountingDecorator(THolder<IActor> &&actor, TCounters *counters)
+            : TTestDecorator(std::move(actor))
+            , Counters(counters)
+        {
+        }
+
+        bool DoBeforeSending(TAutoPtr<IEventHandle> &ev) override {
+            if (ev->Type == TEvents::TSystem::Bootstrap) {
+                return true;
+            }
+            Write("TCountingDecorator::DoBeforeSending");
+            Counters->SendedCount++;
+            return true;
+        }
+
+        bool DoBeforeReceiving(TAutoPtr<IEventHandle> &/*ev*/, const TActorContext &/*ctx*/) override {
+            Write("TCountingDecorator::DoBeforeReceiving");
+            Counters->RecievedCount++;
+            return true;
+        }
+    };
+    
+    bool ScheduledFilterFunc(NActors::TTestActorRuntimeBase& runtime, TAutoPtr<NActors::IEventHandle>& event,
+            TDuration delay, TInstant& deadline) {
+        if (runtime.IsScheduleForActorEnabled(event->GetRecipientRewrite())) {
+            deadline = runtime.GetTimeProvider()->Now() + delay;
+            return false;
+        }
+        return true;
+    }
+
+    THolder<IActor> CreateFizzBuzzSender() {
         THolder<IActor> actor = MakeHolder<TFizzBuzzSender>();
         THolder<IActor> foobar = MakeHolder<TFizzBuzzToFooBar>(std::move(actor));
         THolder<IActor> fizzEraser = MakeHolder<TWordEraser>(std::move(foobar), "Fizz");
         THolder<IActor> buzzEraser = MakeHolder<TWordEraser>(std::move(fizzEraser), "Buzz");
         return MakeHolder<TWithoutWordsDroper>(std::move(buzzEraser));
-    } 
- 
-    Y_UNIT_TEST(Basic) { 
-        TTestActorRuntimeBase runtime(1, false); 
- 
-        runtime.SetScheduledEventFilter(&ScheduledFilterFunc); 
-        runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) { 
-            return false; 
-        }); 
-        runtime.Initialize(); 
- 
-        TActorId edgeActor = runtime.AllocateEdgeActor(); 
-        TVector<THolder<IActor>> actors(1); 
-        actors[0] = CreateFizzBuzzSender(); 
-        //actors[1] = CreateFizzBuzzSender(); 
+    }
+
+    Y_UNIT_TEST(Basic) {
+        TTestActorRuntimeBase runtime(1, false);
+
+        runtime.SetScheduledEventFilter(&ScheduledFilterFunc);
+        runtime.SetEventFilter([](NActors::TTestActorRuntimeBase&, TAutoPtr<NActors::IEventHandle>&) {
+            return false;
+        });
+        runtime.Initialize();
+
+        TActorId edgeActor = runtime.AllocateEdgeActor();
+        TVector<THolder<IActor>> actors(1);
+        actors[0] = CreateFizzBuzzSender();
+        //actors[1] = CreateFizzBuzzSender();
         THolder<IActor> testActor = MakeHolder<TTestMasterActor>(std::move(actors), edgeActor);
-        Write("Start test"); 
-        runtime.Register(testActor.Release()); 
- 
-        TAutoPtr<IEventHandle> handle; 
-        auto ev = runtime.GrabEdgeEventRethrow<TEvents::TEvPing>(handle); 
-        UNIT_ASSERT(ev); 
-        Write("Stop test"); 
-    } 
-} 
+        Write("Start test");
+        runtime.Register(testActor.Release());
+
+        TAutoPtr<IEventHandle> handle;
+        auto ev = runtime.GrabEdgeEventRethrow<TEvents::TEvPing>(handle);
+        UNIT_ASSERT(ev);
+        Write("Stop test");
+    }
+}
diff --git a/library/cpp/actors/testlib/test_runtime.cpp b/library/cpp/actors/testlib/test_runtime.cpp
index 1fc7b1e9ea..6fa25b9965 100644
--- a/library/cpp/actors/testlib/test_runtime.cpp
+++ b/library/cpp/actors/testlib/test_runtime.cpp
@@ -358,12 +358,12 @@ namespace NActors {
             if (!Runtime->EventFilterFunc(*Runtime, ev)) {
                 ui32 nodeId = ev->GetRecipientRewrite().NodeId();
                 Y_VERIFY(nodeId != 0);
-                TNodeDataBase* node = Runtime->Nodes[nodeId].Get(); 
- 
-                if (!AllowSendFrom(node, ev)) { 
-                    return true; 
-                } 
- 
+                TNodeDataBase* node = Runtime->Nodes[nodeId].Get();
+
+                if (!AllowSendFrom(node, ev)) {
+                    return true;
+                }
+
                 ui32 mailboxHint = ev->GetRecipientRewrite().Hint();
                 if (ev->GetTypeRewrite() == ui32(NActors::NLog::EEv::Log)) {
                     const NActors::TActorId loggerActorId = NActors::TActorId(nodeId, "logger");
@@ -373,10 +373,10 @@ namespace NActors {
                         IActor* recipientActor = mailbox->FindActor(ev->GetRecipientRewrite().LocalId());
                         if (recipientActor) {
                             TActorContext ctx(*mailbox, *node->ExecutorThread, GetCycleCountFast(), ev->GetRecipientRewrite());
-                            TActivationContext *prevTlsActivationContext = TlsActivationContext; 
-                            TlsActivationContext = &ctx; 
+                            TActivationContext *prevTlsActivationContext = TlsActivationContext;
+                            TlsActivationContext = &ctx;
                             recipientActor->Receive(ev, ctx);
-                            TlsActivationContext = prevTlsActivationContext; 
+                            TlsActivationContext = prevTlsActivationContext;
                             // we expect the logger to never die in tests
                         }
                     }
@@ -515,18 +515,18 @@ namespace NActors {
         node->ActorSystem->Start();
     }
 
-    bool TTestActorRuntimeBase::AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev) { 
-        ui64 senderLocalId = ev->Sender.LocalId(); 
-        ui64 senderMailboxHint = ev->Sender.Hint(); 
-        TMailboxHeader* senderMailbox = node->MailboxTable->Get(senderMailboxHint); 
-        if (senderMailbox) { 
-            IActor* senderActor = senderMailbox->FindActor(senderLocalId); 
-            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(senderActor); 
-            return !decorator || decorator->BeforeSending(ev); 
-        } 
-        return true; 
-    } 
- 
+    bool TTestActorRuntimeBase::AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev) {
+        ui64 senderLocalId = ev->Sender.LocalId();
+        ui64 senderMailboxHint = ev->Sender.Hint();
+        TMailboxHeader* senderMailbox = node->MailboxTable->Get(senderMailboxHint);
+        if (senderMailbox) {
+            IActor* senderActor = senderMailbox->FindActor(senderLocalId);
+            TTestDecorator *decorator = dynamic_cast<TTestDecorator*>(senderActor);
+            return !decorator || decorator->BeforeSending(ev);
+        }
+        return true;
+    }
+
     TTestActorRuntimeBase::TTestActorRuntimeBase(ui32 nodeCount, ui32 dataCenterCount)
         : TTestActorRuntimeBase(nodeCount, dataCenterCount, false) {
     }
@@ -1547,10 +1547,10 @@ namespace NActors {
         Y_VERIFY(!ev->GetRecipientRewrite().IsService() && (targetNodeIndex == nodeIndex));
         TAutoPtr<IEventHandle> evHolder(ev);
 
-        if (!AllowSendFrom(node, evHolder)) { 
-            return; 
-        } 
- 
+        if (!AllowSendFrom(node, evHolder)) {
+            return;
+        }
+
         ui32 mailboxHint = ev->GetRecipientRewrite().Hint();
         TEventMailBox& mbox = GetMailbox(nodeId, mailboxHint);
         if (!mbox.IsActive(TInstant::MicroSeconds(CurrentTimestamp))) {
@@ -1774,15 +1774,15 @@ namespace NActors {
         }
 
         TStrandingActorDecorator(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors,
-            TSimpleSharedPtr<TStrandingActorDecoratorContext> context, TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) 
+            TSimpleSharedPtr<TStrandingActorDecoratorContext> context, TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker)
             : Delegatee(delegatee)
             , IsSync(isSync)
             , AdditionalActors(additionalActors)
             , Context(context)
             , HasReply(false)
             , Runtime(runtime)
-            , ReplyChecker(createReplyChecker()) 
+            , ReplyChecker(createReplyChecker())
         {
             if (IsSync) {
                 Y_VERIFY(!runtime->IsRealThreads());
@@ -1812,12 +1812,12 @@ namespace NActors {
 
         STFUNC(Reply) {
             Y_VERIFY(!HasReply);
-            IEventHandle *requestEv = Context->Queue->Head(); 
+            IEventHandle *requestEv = Context->Queue->Head();
             TActorId originalSender = requestEv->Sender;
-            HasReply = !ReplyChecker->IsWaitingForMoreResponses(ev.Get()); 
-            if (HasReply) { 
-                delete Context->Queue->Pop(); 
-            } 
+            HasReply = !ReplyChecker->IsWaitingForMoreResponses(ev.Get());
+            if (HasReply) {
+                delete Context->Queue->Pop();
+            }
             ctx.ExecutorThread.Send(ev->Forward(originalSender));
             if (!IsSync && Context->Queue->Head()) {
                 SendHead(ctx);
@@ -1849,7 +1849,7 @@ namespace NActors {
 
         TAutoPtr<IEventHandle> GetForwardedEvent() {
             IEventHandle* ev = Context->Queue->Head();
-            ReplyChecker->OnRequest(ev); 
+            ReplyChecker->OnRequest(ev);
             TAutoPtr<IEventHandle> forwardedEv = ev->HasEvent()
                 ? new IEventHandle(Delegatee, ReplyId, ev->ReleaseBase().Release(), ev->Flags, ev->Cookie)
                 : new IEventHandle(ev->GetTypeRewrite(), ev->Flags, Delegatee, ReplyId, ev->ReleaseChainBuffer(), ev->Cookie);
@@ -1865,7 +1865,7 @@ namespace NActors {
         bool HasReply;
         TDispatchOptions DelegateeOptions;
         TTestActorRuntimeBase* Runtime;
-        THolder<IReplyChecker> ReplyChecker; 
+        THolder<IReplyChecker> ReplyChecker;
     };
 
     void TStrandingActorDecorator::TReplyActor::StateFunc(STFUNC_SIG) {
@@ -1874,28 +1874,28 @@ namespace NActors {
 
     class TStrandingDecoratorFactory : public IStrandingDecoratorFactory {
     public:
-        TStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) 
+        TStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker)
             : Context(new TStrandingActorDecoratorContext())
             , Runtime(runtime)
-            , CreateReplyChecker(createReplyChecker) 
+            , CreateReplyChecker(createReplyChecker)
         {
         }
 
         IActor* Wrap(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors) override {
-            return new TStrandingActorDecorator(delegatee, isSync, additionalActors, Context, Runtime, 
-                CreateReplyChecker); 
+            return new TStrandingActorDecorator(delegatee, isSync, additionalActors, Context, Runtime,
+                CreateReplyChecker);
         }
 
     private:
         TSimpleSharedPtr<TStrandingActorDecoratorContext> Context;
         TTestActorRuntimeBase* Runtime;
-        TReplyCheckerCreator CreateReplyChecker; 
+        TReplyCheckerCreator CreateReplyChecker;
     };
 
-    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker) { 
-        return TAutoPtr<IStrandingDecoratorFactory>(new TStrandingDecoratorFactory(runtime, createReplyChecker)); 
+    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker) {
+        return TAutoPtr<IStrandingDecoratorFactory>(new TStrandingDecoratorFactory(runtime, createReplyChecker));
     }
 
     ui64 DefaultRandomSeed = 9999;
diff --git a/library/cpp/actors/testlib/test_runtime.h b/library/cpp/actors/testlib/test_runtime.h
index 95ac8b0aa4..26e3b45c98 100644
--- a/library/cpp/actors/testlib/test_runtime.h
+++ b/library/cpp/actors/testlib/test_runtime.h
@@ -593,8 +593,8 @@ namespace NActors {
         void CleanupNodes();
         virtual void InitNodeImpl(TNodeDataBase*, size_t);
 
-        static bool AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev); 
- 
+        static bool AllowSendFrom(TNodeDataBase* node, TAutoPtr<IEventHandle>& ev);
+
     protected:
         THolder<INodeFactory> NodeFactory{new TDefaultNodeFactory};
 
@@ -689,28 +689,28 @@ namespace NActors {
         virtual IActor* Wrap(const TActorId& delegatee, bool isSync, const TVector<TActorId>& additionalActors) = 0;
     };
 
-    struct IReplyChecker { 
-        virtual ~IReplyChecker() {} 
-        virtual void OnRequest(IEventHandle *request) = 0; 
-        virtual bool IsWaitingForMoreResponses(IEventHandle *response) = 0; 
-    }; 
- 
-    struct TNoneReplyChecker : IReplyChecker { 
-        void OnRequest(IEventHandle*) override { 
-        } 
- 
-        bool IsWaitingForMoreResponses(IEventHandle*) override { 
-            return false; 
-        } 
-    }; 
- 
-    using TReplyCheckerCreator = std::function<THolder<IReplyChecker>(void)>; 
- 
-    inline THolder<IReplyChecker> CreateNoneReplyChecker() { 
+    struct IReplyChecker {
+        virtual ~IReplyChecker() {}
+        virtual void OnRequest(IEventHandle *request) = 0;
+        virtual bool IsWaitingForMoreResponses(IEventHandle *response) = 0;
+    };
+
+    struct TNoneReplyChecker : IReplyChecker {
+        void OnRequest(IEventHandle*) override {
+        }
+
+        bool IsWaitingForMoreResponses(IEventHandle*) override {
+            return false;
+        }
+    };
+
+    using TReplyCheckerCreator = std::function<THolder<IReplyChecker>(void)>;
+
+    inline THolder<IReplyChecker> CreateNoneReplyChecker() {
         return MakeHolder<TNoneReplyChecker>();
-    } 
- 
-    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime, 
-            TReplyCheckerCreator createReplyChecker = CreateNoneReplyChecker); 
+    }
+
+    TAutoPtr<IStrandingDecoratorFactory> CreateStrandingDecoratorFactory(TTestActorRuntimeBase* runtime,
+            TReplyCheckerCreator createReplyChecker = CreateNoneReplyChecker);
     extern ui64 DefaultRandomSeed;
 }
diff --git a/library/cpp/actors/testlib/ut/ya.make b/library/cpp/actors/testlib/ut/ya.make
index ef16812aed..1d4aec06ff 100644
--- a/library/cpp/actors/testlib/ut/ya.make
+++ b/library/cpp/actors/testlib/ut/ya.make
@@ -1,20 +1,20 @@
-UNITTEST_FOR(library/cpp/actors/testlib) 
- 
-OWNER( 
-    kruall 
-    g:kikimr 
-) 
- 
-FORK_SUBTESTS() 
-SIZE(SMALL) 
- 
- 
-PEERDIR( 
-    library/cpp/actors/core 
-) 
- 
-SRCS( 
-    decorator_ut.cpp 
-) 
- 
-END() 
+UNITTEST_FOR(library/cpp/actors/testlib)
+
+OWNER(
+    kruall
+    g:kikimr
+)
+
+FORK_SUBTESTS()
+SIZE(SMALL)
+
+
+PEERDIR(
+    library/cpp/actors/core
+)
+
+SRCS(
+    decorator_ut.cpp
+)
+
+END()
diff --git a/library/cpp/actors/testlib/ya.make b/library/cpp/actors/testlib/ya.make
index 8818f10458..1afb3f6059 100644
--- a/library/cpp/actors/testlib/ya.make
+++ b/library/cpp/actors/testlib/ya.make
@@ -21,7 +21,7 @@ IF (GCC)
 ENDIF()
 
 END()
- 
-RECURSE_FOR_TESTS( 
-    ut 
-) 
+
+RECURSE_FOR_TESTS(
+    ut
+)