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

1 files changed, 101 insertions, 101 deletions

diff --git a/util/thread/lfstack_ut.cpp b/util/thread/lfstack_ut.cpp
index e20a838f95..00ae2864d7 100644
--- a/util/thread/lfstack_ut.cpp
+++ b/util/thread/lfstack_ut.cpp
@@ -190,55 +190,55 @@ Y_UNIT_TEST_SUITE(TLockFreeStackTests) {
         UNIT_ASSERT_VALUES_EQUAL(1, p.RefCount());
     }
 
-    Y_UNIT_TEST(NoCopyTest) {
-        static unsigned copied = 0;
-        struct TCopyCount {
+    Y_UNIT_TEST(NoCopyTest) { 
+        static unsigned copied = 0; 
+        struct TCopyCount { 
             TCopyCount(int) {
             }
             TCopyCount(const TCopyCount&) {
                 ++copied;
             }
-
+ 
             TCopyCount(TCopyCount&&) {
             }
-
-            TCopyCount& operator=(const TCopyCount&) {
-                ++copied;
-                return *this;
-            }
-
-            TCopyCount& operator=(TCopyCount&&) {
-                return *this;
-            }
-        };
-
-        TLockFreeStack<TCopyCount> stack;
-        stack.Enqueue(TCopyCount(1));
-        TCopyCount val(0);
-        stack.Dequeue(&val);
-        UNIT_ASSERT_VALUES_EQUAL(0, copied);
-    }
-
-    Y_UNIT_TEST(MoveOnlyTest) {
-        TLockFreeStack<THolder<bool>> stack;
-        stack.Enqueue(MakeHolder<bool>(true));
-        THolder<bool> val;
-        stack.Dequeue(&val);
-        UNIT_ASSERT(val);
-        UNIT_ASSERT_VALUES_EQUAL(true, *val);
-    }
-
-    template <class TTest>
-    struct TMultiThreadTester {
-        using ThisType = TMultiThreadTester<TTest>;
-
+ 
+            TCopyCount& operator=(const TCopyCount&) { 
+                ++copied; 
+                return *this; 
+            } 
+ 
+            TCopyCount& operator=(TCopyCount&&) { 
+                return *this; 
+            } 
+        }; 
+ 
+        TLockFreeStack<TCopyCount> stack; 
+        stack.Enqueue(TCopyCount(1)); 
+        TCopyCount val(0); 
+        stack.Dequeue(&val); 
+        UNIT_ASSERT_VALUES_EQUAL(0, copied); 
+    } 
+ 
+    Y_UNIT_TEST(MoveOnlyTest) { 
+        TLockFreeStack<THolder<bool>> stack; 
+        stack.Enqueue(MakeHolder<bool>(true)); 
+        THolder<bool> val; 
+        stack.Dequeue(&val); 
+        UNIT_ASSERT(val); 
+        UNIT_ASSERT_VALUES_EQUAL(true, *val); 
+    } 
+ 
+    template <class TTest> 
+    struct TMultiThreadTester { 
+        using ThisType = TMultiThreadTester<TTest>; 
+ 
         size_t Threads;
         size_t OperationsPerThread;
 
         TCountDownLatch StartLatch;
-        TLockFreeStack<typename TTest::ValueType> Stack;
+        TLockFreeStack<typename TTest::ValueType> Stack; 
 
-        TMultiThreadTester()
+        TMultiThreadTester() 
             : Threads(10)
             , OperationsPerThread(100000)
             , StartLatch(Threads)
@@ -249,23 +249,23 @@ Y_UNIT_TEST_SUITE(TLockFreeStackTests) {
             StartLatch.CountDown();
             StartLatch.Await();
 
-            TVector<typename TTest::ValueType> unused;
+            TVector<typename TTest::ValueType> unused; 
             for (size_t i = 0; i < OperationsPerThread; ++i) {
                 switch (GetCycleCount() % 4) {
                     case 0: {
-                        TTest::Enqueue(Stack, i);
+                        TTest::Enqueue(Stack, i); 
                         break;
                     }
                     case 1: {
-                        TTest::Dequeue(Stack);
+                        TTest::Dequeue(Stack); 
                         break;
                     }
                     case 2: {
-                        TTest::EnqueueAll(Stack);
+                        TTest::EnqueueAll(Stack); 
                         break;
                     }
                     case 3: {
-                        TTest::DequeueAll(Stack);
+                        TTest::DequeueAll(Stack); 
                         break;
                     }
                 }
@@ -276,71 +276,71 @@ Y_UNIT_TEST_SUITE(TLockFreeStackTests) {
             TDeque<NThreading::TLegacyFuture<>> futures;
 
             for (size_t i = 0; i < Threads; ++i) {
-                futures.emplace_back(std::bind(&ThisType::Worker, this));
+                futures.emplace_back(std::bind(&ThisType::Worker, this)); 
             }
             futures.clear();
-            TTest::DequeueAll(Stack);
-        }
-    };
-
-    struct TFreeListTest {
-        using ValueType = int;
-
-        static void Enqueue(TLockFreeStack<int>& stack, size_t i) {
-            stack.Enqueue(static_cast<int>(i));
-        }
-
-        static void Dequeue(TLockFreeStack<int>& stack) {
-            int value;
-            stack.Dequeue(&value);
-        }
-
-        static void EnqueueAll(TLockFreeStack<int>& stack) {
-            TVector<int> values(5);
-            stack.EnqueueAll(values);
-        }
-
-        static void DequeueAll(TLockFreeStack<int>& stack) {
-            TVector<int> value;
-            stack.DequeueAll(&value);
+            TTest::DequeueAll(Stack); 
+        } 
+    }; 
+ 
+    struct TFreeListTest { 
+        using ValueType = int; 
+ 
+        static void Enqueue(TLockFreeStack<int>& stack, size_t i) { 
+            stack.Enqueue(static_cast<int>(i)); 
         }
+ 
+        static void Dequeue(TLockFreeStack<int>& stack) { 
+            int value; 
+            stack.Dequeue(&value); 
+        } 
+ 
+        static void EnqueueAll(TLockFreeStack<int>& stack) { 
+            TVector<int> values(5); 
+            stack.EnqueueAll(values); 
+        } 
+ 
+        static void DequeueAll(TLockFreeStack<int>& stack) { 
+            TVector<int> value; 
+            stack.DequeueAll(&value); 
+        } 
     };
 
     // Test for catching thread sanitizer problems
     Y_UNIT_TEST(TestFreeList) {
-        TMultiThreadTester<TFreeListTest>().Run();
-    }
-
-    struct TMoveTest {
-        using ValueType = THolder<int>;
-
-        static void Enqueue(TLockFreeStack<ValueType>& stack, size_t i) {
-            stack.Enqueue(MakeHolder<int>(static_cast<int>(i)));
-        }
-
-        static void Dequeue(TLockFreeStack<ValueType>& stack) {
-            ValueType value;
-            if (stack.Dequeue(&value)) {
-                UNIT_ASSERT(value);
-            }
-        }
-
-        static void EnqueueAll(TLockFreeStack<ValueType>& stack) {
-            // there is no enqueAll with moving signature in LockFreeStack
-            Enqueue(stack, 0);
-        }
-
-        static void DequeueAll(TLockFreeStack<ValueType>& stack) {
-            TVector<ValueType> values;
-            stack.DequeueAll(&values);
-            for (auto& v : values) {
-                UNIT_ASSERT(v);
-            }
-        }
-    };
-
-    // Test for catching thread sanitizer problems
-    Y_UNIT_TEST(TesMultiThreadMove) {
-        TMultiThreadTester<TMoveTest>().Run();
+        TMultiThreadTester<TFreeListTest>().Run(); 
     }
+ 
+    struct TMoveTest { 
+        using ValueType = THolder<int>; 
+ 
+        static void Enqueue(TLockFreeStack<ValueType>& stack, size_t i) { 
+            stack.Enqueue(MakeHolder<int>(static_cast<int>(i))); 
+        } 
+ 
+        static void Dequeue(TLockFreeStack<ValueType>& stack) { 
+            ValueType value; 
+            if (stack.Dequeue(&value)) { 
+                UNIT_ASSERT(value); 
+            } 
+        } 
+ 
+        static void EnqueueAll(TLockFreeStack<ValueType>& stack) { 
+            // there is no enqueAll with moving signature in LockFreeStack 
+            Enqueue(stack, 0); 
+        } 
+ 
+        static void DequeueAll(TLockFreeStack<ValueType>& stack) { 
+            TVector<ValueType> values; 
+            stack.DequeueAll(&values); 
+            for (auto& v : values) { 
+                UNIT_ASSERT(v); 
+            } 
+        } 
+    }; 
+ 
+    // Test for catching thread sanitizer problems 
+    Y_UNIT_TEST(TesMultiThreadMove) { 
+        TMultiThreadTester<TMoveTest>().Run(); 
+    } 
 }