Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 237 insertions, 237 deletions

diff --git a/library/cpp/threading/future/future_ut.cpp b/library/cpp/threading/future/future_ut.cpp
index 05950a568d..636b113f2f 100644
--- a/library/cpp/threading/future/future_ut.cpp
+++ b/library/cpp/threading/future/future_ut.cpp
@@ -62,180 +62,180 @@ namespace {
 
 }
 
-    ////////////////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////////////// 
 
     Y_UNIT_TEST_SUITE(TFutureTest) {
         Y_UNIT_TEST(ShouldInitiallyHasNoValue) {
-            TPromise<int> promise;
-            UNIT_ASSERT(!promise.HasValue());
+            TPromise<int> promise; 
+            UNIT_ASSERT(!promise.HasValue()); 
 
-            promise = NewPromise<int>();
-            UNIT_ASSERT(!promise.HasValue());
+            promise = NewPromise<int>(); 
+            UNIT_ASSERT(!promise.HasValue()); 
 
-            TFuture<int> future;
-            UNIT_ASSERT(!future.HasValue());
+            TFuture<int> future; 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            future = promise.GetFuture();
-            UNIT_ASSERT(!future.HasValue());
-        }
+            future = promise.GetFuture(); 
+            UNIT_ASSERT(!future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldInitiallyHasNoValueVoid) {
-            TPromise<void> promise;
-            UNIT_ASSERT(!promise.HasValue());
+            TPromise<void> promise; 
+            UNIT_ASSERT(!promise.HasValue()); 
 
-            promise = NewPromise();
-            UNIT_ASSERT(!promise.HasValue());
+            promise = NewPromise(); 
+            UNIT_ASSERT(!promise.HasValue()); 
 
-            TFuture<void> future;
-            UNIT_ASSERT(!future.HasValue());
+            TFuture<void> future; 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            future = promise.GetFuture();
-            UNIT_ASSERT(!future.HasValue());
-        }
+            future = promise.GetFuture(); 
+            UNIT_ASSERT(!future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldStoreValue) {
-            TPromise<int> promise = NewPromise<int>();
-            promise.SetValue(123);
-            UNIT_ASSERT(promise.HasValue());
-            UNIT_ASSERT_EQUAL(promise.GetValue(), 123);
+            TPromise<int> promise = NewPromise<int>(); 
+            promise.SetValue(123); 
+            UNIT_ASSERT(promise.HasValue()); 
+            UNIT_ASSERT_EQUAL(promise.GetValue(), 123); 
 
-            TFuture<int> future = promise.GetFuture();
-            UNIT_ASSERT(future.HasValue());
-            UNIT_ASSERT_EQUAL(future.GetValue(), 123);
+            TFuture<int> future = promise.GetFuture(); 
+            UNIT_ASSERT(future.HasValue()); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 123); 
 
-            future = MakeFuture(345);
-            UNIT_ASSERT(future.HasValue());
-            UNIT_ASSERT_EQUAL(future.GetValue(), 345);
-        }
+            future = MakeFuture(345); 
+            UNIT_ASSERT(future.HasValue()); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 345); 
+        } 
 
         Y_UNIT_TEST(ShouldStoreValueVoid) {
-            TPromise<void> promise = NewPromise();
-            promise.SetValue();
-            UNIT_ASSERT(promise.HasValue());
+            TPromise<void> promise = NewPromise(); 
+            promise.SetValue(); 
+            UNIT_ASSERT(promise.HasValue()); 
 
-            TFuture<void> future = promise.GetFuture();
-            UNIT_ASSERT(future.HasValue());
+            TFuture<void> future = promise.GetFuture(); 
+            UNIT_ASSERT(future.HasValue()); 
 
-            future = MakeFuture();
-            UNIT_ASSERT(future.HasValue());
-        }
+            future = MakeFuture(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
-        struct TTestCallback {
-            int Value;
+        struct TTestCallback { 
+            int Value; 
 
-            TTestCallback(int value)
-                : Value(value)
-            {
-            }
+            TTestCallback(int value) 
+                : Value(value) 
+            { 
+            } 
 
-            void Callback(const TFuture<int>& future) {
-                Value += future.GetValue();
-            }
+            void Callback(const TFuture<int>& future) { 
+                Value += future.GetValue(); 
+            } 
 
-            int Func(const TFuture<int>& future) {
-                return (Value += future.GetValue());
-            }
+            int Func(const TFuture<int>& future) { 
+                return (Value += future.GetValue()); 
+            } 
 
-            void VoidFunc(const TFuture<int>& future) {
-                future.GetValue();
-            }
+            void VoidFunc(const TFuture<int>& future) { 
+                future.GetValue(); 
+            } 
 
-            TFuture<int> FutureFunc(const TFuture<int>& future) {
-                return MakeFuture(Value += future.GetValue());
-            }
+            TFuture<int> FutureFunc(const TFuture<int>& future) { 
+                return MakeFuture(Value += future.GetValue()); 
+            } 
 
-            TPromise<void> Signal = NewPromise();
-            TFuture<void> FutureVoidFunc(const TFuture<int>& future) {
-                future.GetValue();
-                return Signal;
-            }
-        };
+            TPromise<void> Signal = NewPromise(); 
+            TFuture<void> FutureVoidFunc(const TFuture<int>& future) { 
+                future.GetValue(); 
+                return Signal; 
+            } 
+        }; 
 
         Y_UNIT_TEST(ShouldInvokeCallback) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<int> future = promise.GetFuture()
-                                      .Subscribe([&](const TFuture<int>& theFuture) { return callback.Callback(theFuture); });
+            TTestCallback callback(123); 
+            TFuture<int> future = promise.GetFuture() 
+                                      .Subscribe([&](const TFuture<int>& theFuture) { return callback.Callback(theFuture); }); 
 
-            promise.SetValue(456);
-            UNIT_ASSERT_EQUAL(future.GetValue(), 456);
-            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456);
-        }
+            promise.SetValue(456); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 456); 
+            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456); 
+        } 
 
         Y_UNIT_TEST(ShouldApplyFunc) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<int> future = promise.GetFuture()
+            TTestCallback callback(123); 
+            TFuture<int> future = promise.GetFuture() 
                                       .Apply([&](const auto& theFuture) { return callback.Func(theFuture); });
 
-            promise.SetValue(456);
-            UNIT_ASSERT_EQUAL(future.GetValue(), 123 + 456);
-            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456);
-        }
+            promise.SetValue(456); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 123 + 456); 
+            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456); 
+        } 
 
         Y_UNIT_TEST(ShouldApplyVoidFunc) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<void> future = promise.GetFuture()
+            TTestCallback callback(123); 
+            TFuture<void> future = promise.GetFuture() 
                                        .Apply([&](const auto& theFuture) { return callback.VoidFunc(theFuture); });
 
-            promise.SetValue(456);
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise.SetValue(456); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldApplyFutureFunc) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<int> future = promise.GetFuture()
+            TTestCallback callback(123); 
+            TFuture<int> future = promise.GetFuture() 
                                       .Apply([&](const auto& theFuture) { return callback.FutureFunc(theFuture); });
 
-            promise.SetValue(456);
-            UNIT_ASSERT_EQUAL(future.GetValue(), 123 + 456);
-            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456);
-        }
+            promise.SetValue(456); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 123 + 456); 
+            UNIT_ASSERT_EQUAL(callback.Value, 123 + 456); 
+        } 
 
         Y_UNIT_TEST(ShouldApplyFutureVoidFunc) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<void> future = promise.GetFuture()
+            TTestCallback callback(123); 
+            TFuture<void> future = promise.GetFuture() 
                                        .Apply([&](const auto& theFuture) { return callback.FutureVoidFunc(theFuture); });
 
-            promise.SetValue(456);
-            UNIT_ASSERT(!future.HasValue());
+            promise.SetValue(456); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            callback.Signal.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            callback.Signal.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldIgnoreResultIfAsked) {
-            TPromise<int> promise = NewPromise<int>();
+            TPromise<int> promise = NewPromise<int>(); 
 
-            TTestCallback callback(123);
-            TFuture<int> future = promise.GetFuture().IgnoreResult().Return(42);
+            TTestCallback callback(123); 
+            TFuture<int> future = promise.GetFuture().IgnoreResult().Return(42); 
 
-            promise.SetValue(456);
-            UNIT_ASSERT_EQUAL(future.GetValue(), 42);
-        }
+            promise.SetValue(456); 
+            UNIT_ASSERT_EQUAL(future.GetValue(), 42); 
+        } 
 
-        class TCustomException: public yexception {
-        };
+        class TCustomException: public yexception { 
+        }; 
 
         Y_UNIT_TEST(ShouldRethrowException) {
-            TPromise<int> promise = NewPromise<int>();
-            try {
-                ythrow TCustomException();
-            } catch (...) {
-                promise.SetException(std::current_exception());
-            }
-
-            UNIT_ASSERT(!promise.HasValue());
-            UNIT_ASSERT(promise.HasException());
-            UNIT_ASSERT_EXCEPTION(promise.GetValue(), TCustomException);
+            TPromise<int> promise = NewPromise<int>(); 
+            try { 
+                ythrow TCustomException(); 
+            } catch (...) { 
+                promise.SetException(std::current_exception()); 
+            } 
+
+            UNIT_ASSERT(!promise.HasValue()); 
+            UNIT_ASSERT(promise.HasException()); 
+            UNIT_ASSERT_EXCEPTION(promise.GetValue(), TCustomException); 
             UNIT_ASSERT_EXCEPTION(promise.TryRethrow(), TCustomException);
         }
 
@@ -261,36 +261,36 @@ namespace {
 
 
         Y_UNIT_TEST(ShouldWaitExceptionOrAll) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
             TFuture<void> future = WaitExceptionOrAll(promise1, promise2);
-            UNIT_ASSERT(!future.HasValue());
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(!future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitExceptionOrAllVector) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
-            TVector<TFuture<void>> promises;
-            promises.push_back(promise1);
-            promises.push_back(promise2);
+            TVector<TFuture<void>> promises; 
+            promises.push_back(promise1); 
+            promises.push_back(promise2); 
 
             TFuture<void> future = WaitExceptionOrAll(promises);
-            UNIT_ASSERT(!future.HasValue());
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(!future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitExceptionOrAllVectorWithValueType) {
             TPromise<int> promise1 = NewPromise<int>();
@@ -311,47 +311,47 @@ namespace {
         }
 
         Y_UNIT_TEST(ShouldWaitExceptionOrAllList) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
-            std::list<TFuture<void>> promises;
-            promises.push_back(promise1);
-            promises.push_back(promise2);
+            std::list<TFuture<void>> promises; 
+            promises.push_back(promise1); 
+            promises.push_back(promise2); 
 
             TFuture<void> future = WaitExceptionOrAll(promises);
-            UNIT_ASSERT(!future.HasValue());
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(!future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitExceptionOrAllVectorEmpty) {
-            TVector<TFuture<void>> promises;
+            TVector<TFuture<void>> promises; 
 
             TFuture<void> future = WaitExceptionOrAll(promises);
-            UNIT_ASSERT(future.HasValue());
-        }
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitAnyVector) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
-            TVector<TFuture<void>> promises;
-            promises.push_back(promise1);
-            promises.push_back(promise2);
+            TVector<TFuture<void>> promises; 
+            promises.push_back(promise1); 
+            promises.push_back(promise2); 
 
-            TFuture<void> future = WaitAny(promises);
-            UNIT_ASSERT(!future.HasValue());
+            TFuture<void> future = WaitAny(promises); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
 
         Y_UNIT_TEST(ShouldWaitAnyVectorWithValueType) {
@@ -373,112 +373,112 @@ namespace {
         }
 
         Y_UNIT_TEST(ShouldWaitAnyList) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
-            std::list<TFuture<void>> promises;
-            promises.push_back(promise1);
-            promises.push_back(promise2);
+            std::list<TFuture<void>> promises; 
+            promises.push_back(promise1); 
+            promises.push_back(promise2); 
 
-            TFuture<void> future = WaitAny(promises);
-            UNIT_ASSERT(!future.HasValue());
+            TFuture<void> future = WaitAny(promises); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitAnyVectorEmpty) {
-            TVector<TFuture<void>> promises;
+            TVector<TFuture<void>> promises; 
 
-            TFuture<void> future = WaitAny(promises);
-            UNIT_ASSERT(future.HasValue());
-        }
+            TFuture<void> future = WaitAny(promises); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldWaitAny) {
-            TPromise<void> promise1 = NewPromise();
-            TPromise<void> promise2 = NewPromise();
+            TPromise<void> promise1 = NewPromise(); 
+            TPromise<void> promise2 = NewPromise(); 
 
-            TFuture<void> future = WaitAny(promise1, promise2);
-            UNIT_ASSERT(!future.HasValue());
+            TFuture<void> future = WaitAny(promise1, promise2); 
+            UNIT_ASSERT(!future.HasValue()); 
 
-            promise1.SetValue();
-            UNIT_ASSERT(future.HasValue());
+            promise1.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
 
-            promise2.SetValue();
-            UNIT_ASSERT(future.HasValue());
-        }
+            promise2.SetValue(); 
+            UNIT_ASSERT(future.HasValue()); 
+        } 
 
         Y_UNIT_TEST(ShouldStoreTypesWithoutDefaultConstructor) {
-            // compileability test
-            struct TRec {
-                explicit TRec(int) {
-                }
-            };
+            // compileability test 
+            struct TRec { 
+                explicit TRec(int) { 
+                } 
+            }; 
 
-            auto promise = NewPromise<TRec>();
-            promise.SetValue(TRec(1));
+            auto promise = NewPromise<TRec>(); 
+            promise.SetValue(TRec(1)); 
 
-            auto future = MakeFuture(TRec(1));
-            const auto& rec = future.GetValue();
-            Y_UNUSED(rec);
-        }
+            auto future = MakeFuture(TRec(1)); 
+            const auto& rec = future.GetValue(); 
+            Y_UNUSED(rec); 
+        } 
 
         Y_UNIT_TEST(ShouldStoreMovableTypes) {
-            // compileability test
-            struct TRec : TMoveOnly {
-                explicit TRec(int) {
-                }
-            };
+            // compileability test 
+            struct TRec : TMoveOnly { 
+                explicit TRec(int) { 
+                } 
+            }; 
 
-            auto promise = NewPromise<TRec>();
-            promise.SetValue(TRec(1));
+            auto promise = NewPromise<TRec>(); 
+            promise.SetValue(TRec(1)); 
 
-            auto future = MakeFuture(TRec(1));
-            const auto& rec = future.GetValue();
-            Y_UNUSED(rec);
-        }
+            auto future = MakeFuture(TRec(1)); 
+            const auto& rec = future.GetValue(); 
+            Y_UNUSED(rec); 
+        } 
 
         Y_UNIT_TEST(ShouldMoveMovableTypes) {
-            // compileability test
-            struct TRec : TMoveOnly {
-                explicit TRec(int) {
-                }
-            };
+            // compileability test 
+            struct TRec : TMoveOnly { 
+                explicit TRec(int) { 
+                } 
+            }; 
 
-            auto promise = NewPromise<TRec>();
-            promise.SetValue(TRec(1));
+            auto promise = NewPromise<TRec>(); 
+            promise.SetValue(TRec(1)); 
 
-            auto future = MakeFuture(TRec(1));
-            auto rec = future.ExtractValue();
-            Y_UNUSED(rec);
-        }
+            auto future = MakeFuture(TRec(1)); 
+            auto rec = future.ExtractValue(); 
+            Y_UNUSED(rec); 
+        } 
 
         Y_UNIT_TEST(ShouldNotExtractAfterGet) {
-            TPromise<int> promise = NewPromise<int>();
-            promise.SetValue(123);
-            UNIT_ASSERT(promise.HasValue());
-            UNIT_ASSERT_EQUAL(promise.GetValue(), 123);
-            UNIT_CHECK_GENERATED_EXCEPTION(promise.ExtractValue(), TFutureException);
-        }
+            TPromise<int> promise = NewPromise<int>(); 
+            promise.SetValue(123); 
+            UNIT_ASSERT(promise.HasValue()); 
+            UNIT_ASSERT_EQUAL(promise.GetValue(), 123); 
+            UNIT_CHECK_GENERATED_EXCEPTION(promise.ExtractValue(), TFutureException); 
+        } 
 
         Y_UNIT_TEST(ShouldNotGetAfterExtract) {
-            TPromise<int> promise = NewPromise<int>();
-            promise.SetValue(123);
-            UNIT_ASSERT(promise.HasValue());
-            UNIT_ASSERT_EQUAL(promise.ExtractValue(), 123);
-            UNIT_CHECK_GENERATED_EXCEPTION(promise.GetValue(), TFutureException);
-        }
+            TPromise<int> promise = NewPromise<int>(); 
+            promise.SetValue(123); 
+            UNIT_ASSERT(promise.HasValue()); 
+            UNIT_ASSERT_EQUAL(promise.ExtractValue(), 123); 
+            UNIT_CHECK_GENERATED_EXCEPTION(promise.GetValue(), TFutureException); 
+        } 
 
         Y_UNIT_TEST(ShouldNotExtractAfterExtract) {
-            TPromise<int> promise = NewPromise<int>();
-            promise.SetValue(123);
-            UNIT_ASSERT(promise.HasValue());
-            UNIT_ASSERT_EQUAL(promise.ExtractValue(), 123);
-            UNIT_CHECK_GENERATED_EXCEPTION(promise.ExtractValue(), TFutureException);
-        }
+            TPromise<int> promise = NewPromise<int>(); 
+            promise.SetValue(123); 
+            UNIT_ASSERT(promise.HasValue()); 
+            UNIT_ASSERT_EQUAL(promise.ExtractValue(), 123); 
+            UNIT_CHECK_GENERATED_EXCEPTION(promise.ExtractValue(), TFutureException); 
+        } 
 
         Y_UNIT_TEST(ShouldNotExtractFromSharedDefault) {
             UNIT_CHECK_GENERATED_EXCEPTION(MakeFuture<int>().ExtractValue(), TFutureException);