Restoring authorship annotation for <[email protected]>. Commit 1 of 2.

1 files changed, 76 insertions, 76 deletions

diff --git a/util/system/condvar_ut.cpp b/util/system/condvar_ut.cpp
index 5130a18d32a..696516c810b 100644
--- a/util/system/condvar_ut.cpp
+++ b/util/system/condvar_ut.cpp
@@ -4,8 +4,8 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
-#include <util/system/atomic.h>
-#include <util/system/atomic_ops.h>
+#include <util/system/atomic.h> 
+#include <util/system/atomic_ops.h> 
 #include <util/thread/pool.h>
 
 class TCondVarTest: public TTestBase {
@@ -28,12 +28,12 @@ class TCondVarTest: public TTestBase {
         TCondVar condVar1;
         TCondVar condVar2;
 
-        TAtomic stopWaiting;
+        TAtomic stopWaiting; 
 
-        TAtomic in;
-        TAtomic out;
+        TAtomic in; 
+        TAtomic out; 
 
-        TAtomic waited;
+        TAtomic waited; 
 
         bool failed;
     };
@@ -61,36 +61,17 @@ class TCondVarTest: public TTestBase {
         Data_.failed = true; \
     }
         void RunBasics() {
-            Y_ASSERT(TotalIds_ == 3);
+            Y_ASSERT(TotalIds_ == 3); 
 
             if (Id_ < 2) {
                 TGuard<TMutex> guard(Data_.mutex);
-                while (!AtomicGet(Data_.stopWaiting)) {
+                while (!AtomicGet(Data_.stopWaiting)) { 
                     bool res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1));
                     FAIL_ASSERT(res == true);
                 }
             } else {
                 usleep(100000);
-                AtomicSet(Data_.stopWaiting, true);
-
-                TGuard<TMutex> guard(Data_.mutex);
-                Data_.condVar1.Signal();
-                Data_.condVar1.Signal();
-            }
-        }
-
-        void RunBasicsWithPredicate() {
-            Y_ASSERT(TotalIds_ == 3);
-
-            if (Id_ < 2) {
-                TGuard<TMutex> guard(Data_.mutex);
-                const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                    return AtomicGet(Data_.stopWaiting);
-                });
-                FAIL_ASSERT(res == true);
-            } else {
-                usleep(100000);
-                AtomicSet(Data_.stopWaiting, true);
+                AtomicSet(Data_.stopWaiting, true); 
 
                 TGuard<TMutex> guard(Data_.mutex);
                 Data_.condVar1.Signal();
@@ -98,63 +79,82 @@ class TCondVarTest: public TTestBase {
             }
         }
 
+        void RunBasicsWithPredicate() { 
+            Y_ASSERT(TotalIds_ == 3); 
+ 
+            if (Id_ < 2) { 
+                TGuard<TMutex> guard(Data_.mutex); 
+                const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] { 
+                    return AtomicGet(Data_.stopWaiting); 
+                }); 
+                FAIL_ASSERT(res == true); 
+            } else { 
+                usleep(100000); 
+                AtomicSet(Data_.stopWaiting, true); 
+ 
+                TGuard<TMutex> guard(Data_.mutex); 
+                Data_.condVar1.Signal(); 
+                Data_.condVar1.Signal(); 
+            } 
+        } 
+ 
         void RunSyncronize() {
             for (size_t i = 0; i < 10; ++i) {
                 TGuard<TMutex> guard(Data_.mutex);
-                AtomicIncrement(Data_.in);
-                if (AtomicGet(Data_.in) == TotalIds_) {
-                    AtomicSet(Data_.out, 0);
+                AtomicIncrement(Data_.in); 
+                if (AtomicGet(Data_.in) == TotalIds_) { 
+                    AtomicSet(Data_.out, 0); 
                     Data_.condVar1.BroadCast();
                 } else {
-                    AtomicIncrement(Data_.waited);
-                    while (AtomicGet(Data_.in) < TotalIds_) {
+                    AtomicIncrement(Data_.waited); 
+                    while (AtomicGet(Data_.in) < TotalIds_) { 
                         bool res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1));
                         FAIL_ASSERT(res == true);
                     }
                 }
 
-                AtomicIncrement(Data_.out);
-                if (AtomicGet(Data_.out) == TotalIds_) {
-                    AtomicSet(Data_.in, 0);
+                AtomicIncrement(Data_.out); 
+                if (AtomicGet(Data_.out) == TotalIds_) { 
+                    AtomicSet(Data_.in, 0); 
                     Data_.condVar2.BroadCast();
                 } else {
-                    while (AtomicGet(Data_.out) < TotalIds_) {
+                    while (AtomicGet(Data_.out) < TotalIds_) { 
                         bool res = Data_.condVar2.WaitT(Data_.mutex, TDuration::Seconds(1));
                         FAIL_ASSERT(res == true);
                     }
                 }
             }
 
-            FAIL_ASSERT(AtomicGet(Data_.waited) == (TotalIds_ - 1) * 10);
-        }
-
-        void RunSyncronizeWithPredicate() {
-            for (size_t i = 0; i < 10; ++i) {
-                TGuard<TMutex> guard(Data_.mutex);
-                AtomicIncrement(Data_.in);
-                if (AtomicGet(Data_.in) == TotalIds_) {
-                    AtomicSet(Data_.out, 0);
-                    Data_.condVar1.BroadCast();
-                } else {
-                    AtomicIncrement(Data_.waited);
-                    const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                        return AtomicGet(Data_.in) >= TotalIds_;
-                    });
-                    FAIL_ASSERT(res == true);
-                }
-
-                AtomicIncrement(Data_.out);
-                if (AtomicGet(Data_.out) == TotalIds_) {
-                    AtomicSet(Data_.in, 0);
-                    Data_.condVar2.BroadCast();
-                } else {
-                    const auto res = Data_.condVar2.WaitT(Data_.mutex, TDuration::Seconds(1), [&] {
-                        return AtomicGet(Data_.out) >= TotalIds_;
-                    });
-                    FAIL_ASSERT(res == true);
-                }
-            }
-
+            FAIL_ASSERT(AtomicGet(Data_.waited) == (TotalIds_ - 1) * 10); 
+        } 
+ 
+        void RunSyncronizeWithPredicate() { 
+            for (size_t i = 0; i < 10; ++i) { 
+                TGuard<TMutex> guard(Data_.mutex); 
+                AtomicIncrement(Data_.in); 
+                if (AtomicGet(Data_.in) == TotalIds_) { 
+                    AtomicSet(Data_.out, 0); 
+                    Data_.condVar1.BroadCast(); 
+                } else { 
+                    AtomicIncrement(Data_.waited); 
+                    const auto res = Data_.condVar1.WaitT(Data_.mutex, TDuration::Seconds(1), [&] { 
+                        return AtomicGet(Data_.in) >= TotalIds_; 
+                    }); 
+                    FAIL_ASSERT(res == true); 
+                } 
+ 
+                AtomicIncrement(Data_.out); 
+                if (AtomicGet(Data_.out) == TotalIds_) { 
+                    AtomicSet(Data_.in, 0); 
+                    Data_.condVar2.BroadCast(); 
+                } else { 
+                    const auto res = Data_.condVar2.WaitT(Data_.mutex, TDuration::Seconds(1), [&] { 
+                        return AtomicGet(Data_.out) >= TotalIds_; 
+                    }); 
+                    FAIL_ASSERT(res == true); 
+                } 
+            } 
+ 
             FAIL_ASSERT(Data_.waited == (TotalIds_ - 1) * 10);
         }
 #undef FAIL_ASSERT
@@ -162,7 +162,7 @@ class TCondVarTest: public TTestBase {
     private:
         PFunc Func_;
         size_t Id_;
-        TAtomicBase TotalIds_;
+        TAtomicBase TotalIds_; 
         TSharedData& Data_;
     };
 
@@ -181,17 +181,17 @@ private:
         RUN_CYCLE(RunBasics, 3);
     }
 
-    inline void TestBasicsWithPredicate() {
-        RUN_CYCLE(RunBasicsWithPredicate, 3);
-    }
-
+    inline void TestBasicsWithPredicate() { 
+        RUN_CYCLE(RunBasicsWithPredicate, 3); 
+    } 
+ 
     inline void TestSyncronize() {
         RUN_CYCLE(RunSyncronize, 6);
     }
-
-    inline void TestSyncronizeWithPredicate() {
-        RUN_CYCLE(RunSyncronizeWithPredicate, 6);
-    }
+ 
+    inline void TestSyncronizeWithPredicate() { 
+        RUN_CYCLE(RunSyncronizeWithPredicate, 6); 
+    } 
 #undef RUN_CYCLE
     TSharedData Data_;
     TThreadPool Q_;