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

1 files changed, 59 insertions, 59 deletions

diff --git a/library/cpp/threading/future/future_ut.cpp b/library/cpp/threading/future/future_ut.cpp
index 05950a568d..a9d5a6cfbd 100644
--- a/library/cpp/threading/future/future_ut.cpp
+++ b/library/cpp/threading/future/future_ut.cpp
@@ -1,7 +1,7 @@
-#include "future.h"
-
+#include "future.h" 
+ 
 #include <library/cpp/testing/unittest/registar.h>
-
+ 
 #include <list>
 #include <type_traits>
 
@@ -63,168 +63,168 @@ namespace {
 }
 
     ////////////////////////////////////////////////////////////////////////////////
-
+ 
     Y_UNIT_TEST_SUITE(TFutureTest) {
         Y_UNIT_TEST(ShouldInitiallyHasNoValue) {
             TPromise<int> promise;
             UNIT_ASSERT(!promise.HasValue());
-
+ 
             promise = NewPromise<int>();
             UNIT_ASSERT(!promise.HasValue());
-
+ 
             TFuture<int> future;
             UNIT_ASSERT(!future.HasValue());
-
+ 
             future = promise.GetFuture();
             UNIT_ASSERT(!future.HasValue());
         }
-
+ 
         Y_UNIT_TEST(ShouldInitiallyHasNoValueVoid) {
             TPromise<void> promise;
             UNIT_ASSERT(!promise.HasValue());
-
+ 
             promise = NewPromise();
             UNIT_ASSERT(!promise.HasValue());
-
+ 
             TFuture<void> future;
             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);
-
+ 
             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);
         }
-
+ 
         Y_UNIT_TEST(ShouldStoreValueVoid) {
             TPromise<void> promise = NewPromise();
             promise.SetValue();
             UNIT_ASSERT(promise.HasValue());
-
+ 
             TFuture<void> future = promise.GetFuture();
             UNIT_ASSERT(future.HasValue());
-
+ 
             future = MakeFuture();
             UNIT_ASSERT(future.HasValue());
         }
-
+ 
         struct TTestCallback {
             int Value;
-
+ 
             TTestCallback(int value)
                 : Value(value)
             {
             }
-
+ 
             void Callback(const TFuture<int>& future) {
                 Value += future.GetValue();
             }
-
+ 
             int Func(const TFuture<int>& future) {
                 return (Value += future.GetValue());
             }
-
+ 
             void VoidFunc(const TFuture<int>& future) {
                 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;
             }
         };
-
+ 
         Y_UNIT_TEST(ShouldInvokeCallback) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             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);
         }
-
+ 
         Y_UNIT_TEST(ShouldApplyFunc) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             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);
         }
-
+ 
         Y_UNIT_TEST(ShouldApplyVoidFunc) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             TTestCallback callback(123);
             TFuture<void> future = promise.GetFuture()
                                        .Apply([&](const auto& theFuture) { return callback.VoidFunc(theFuture); });
-
+ 
             promise.SetValue(456);
             UNIT_ASSERT(future.HasValue());
         }
-
+ 
         Y_UNIT_TEST(ShouldApplyFutureFunc) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             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);
         }
-
+ 
         Y_UNIT_TEST(ShouldApplyFutureVoidFunc) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             TTestCallback callback(123);
             TFuture<void> future = promise.GetFuture()
                                        .Apply([&](const auto& theFuture) { return callback.FutureVoidFunc(theFuture); });
-
+ 
             promise.SetValue(456);
             UNIT_ASSERT(!future.HasValue());
-
+ 
             callback.Signal.SetValue();
             UNIT_ASSERT(future.HasValue());
         }
-
+ 
         Y_UNIT_TEST(ShouldIgnoreResultIfAsked) {
             TPromise<int> promise = NewPromise<int>();
-
+ 
             TTestCallback callback(123);
             TFuture<int> future = promise.GetFuture().IgnoreResult().Return(42);
-
+ 
             promise.SetValue(456);
             UNIT_ASSERT_EQUAL(future.GetValue(), 42);
         }
-
+ 
         class TCustomException: public yexception {
         };
-
+ 
         Y_UNIT_TEST(ShouldRethrowException) {
             TPromise<int> promise = NewPromise<int>();
             try {
@@ -238,7 +238,7 @@ namespace {
             UNIT_ASSERT_EXCEPTION(promise.GetValue(), TCustomException);
             UNIT_ASSERT_EXCEPTION(promise.TryRethrow(), TCustomException);
         }
-
+ 
         Y_UNIT_TEST(ShouldRethrowCallbackException) {
             TPromise<int> promise = NewPromise<int>();
             TFuture<int> future = promise.GetFuture();
@@ -263,21 +263,21 @@ namespace {
         Y_UNIT_TEST(ShouldWaitExceptionOrAll) {
             TPromise<void> promise1 = NewPromise();
             TPromise<void> promise2 = NewPromise();
-
+ 
             TFuture<void> future = WaitExceptionOrAll(promise1, promise2);
             UNIT_ASSERT(!future.HasValue());
-
+ 
             promise1.SetValue();
             UNIT_ASSERT(!future.HasValue());
-
+ 
             promise2.SetValue();
             UNIT_ASSERT(future.HasValue());
         }
-
+ 
         Y_UNIT_TEST(ShouldWaitExceptionOrAllVector) {
             TPromise<void> promise1 = NewPromise();
             TPromise<void> promise2 = NewPromise();
-
+ 
             TVector<TFuture<void>> promises;
             promises.push_back(promise1);
             promises.push_back(promise2);
@@ -403,21 +403,21 @@ namespace {
 
             TFuture<void> future = WaitAny(promise1, promise2);
             UNIT_ASSERT(!future.HasValue());
-
+ 
             promise1.SetValue();
             UNIT_ASSERT(future.HasValue());
-
+ 
             promise2.SetValue();
             UNIT_ASSERT(future.HasValue());
         }
-
+ 
         Y_UNIT_TEST(ShouldStoreTypesWithoutDefaultConstructor) {
             // compileability test
             struct TRec {
                 explicit TRec(int) {
                 }
             };
-
+ 
             auto promise = NewPromise<TRec>();
             promise.SetValue(TRec(1));
 
@@ -425,22 +425,22 @@ namespace {
             const auto& rec = future.GetValue();
             Y_UNUSED(rec);
         }
-
+ 
         Y_UNIT_TEST(ShouldStoreMovableTypes) {
             // compileability test
             struct TRec : TMoveOnly {
                 explicit TRec(int) {
                 }
             };
-
+ 
             auto promise = NewPromise<TRec>();
             promise.SetValue(TRec(1));
-
+ 
             auto future = MakeFuture(TRec(1));
             const auto& rec = future.GetValue();
             Y_UNUSED(rec);
         }
-
+ 
         Y_UNIT_TEST(ShouldMoveMovableTypes) {
             // compileability test
             struct TRec : TMoveOnly {